mirror of
https://github.com/lovell/sharp.git
synced 2025-07-09 02:30:12 +02:00
Include and publish TypeScript definitions (#3370)
Definitions are a snapshot taken from `@types/sharp`, which remain under the terms of MIT licensing.
This commit is contained in:
Espen Hovlandsdal
GitHub
parent
286a322622
commit
aa5f0f4e40
1
.github/CONTRIBUTING.md
vendored
1
.github/CONTRIBUTING.md
vendored
@ -33,6 +33,7 @@ To test C++ changes, you can compile the module using `npm install --build-from-
|
||||
|
||||
Please add JavaScript [unit tests](https://github.com/lovell/sharp/tree/main/test/unit) to cover your new feature.
|
||||
A test coverage report for the JavaScript code is generated in the `coverage/lcov-report` directory.
|
||||
Please also update the [TypeScript definitions](https://github.com/lovell/sharp/tree/main/lib/index.d.ts), along with the [type definition tests](https://github.com/lovell/sharp/tree/main/test/types/sharp.test-d.ts).
|
||||
|
||||
Where possible, the functional tests use gradient-based perceptual hashes
|
||||
based on [dHash](http://www.hackerfactor.com/blog/index.php?/archives/529-Kind-of-Like-That.html)
|
||||
|
||||
1567
lib/index.d.ts
vendored
Normal file
1567
lib/index.d.ts
vendored
Normal file
File diff suppressed because it is too large
Load Diff
11
package.json
11
package.json
@ -90,16 +90,18 @@
|
||||
"scripts": {
|
||||
"install": "(node install/libvips && node install/dll-copy && prebuild-install) || (node install/can-compile && node-gyp rebuild && node install/dll-copy)",
|
||||
"clean": "rm -rf node_modules/ build/ vendor/ .nyc_output/ coverage/ test/fixtures/output.*",
|
||||
"test": "npm run test-lint && npm run test-unit && npm run test-licensing",
|
||||
"test": "npm run test-lint && npm run test-unit && npm run test-licensing && npm run test-types",
|
||||
"test-lint": "semistandard && cpplint",
|
||||
"test-unit": "nyc --reporter=lcov --reporter=text --check-coverage --branches=100 mocha",
|
||||
"test-licensing": "license-checker --production --summary --onlyAllow=\"Apache-2.0;BSD;ISC;MIT\"",
|
||||
"test-leak": "./test/leak/leak.sh",
|
||||
"test-types": "tsd",
|
||||
"docs-build": "node docs/build && node docs/search-index/build",
|
||||
"docs-serve": "cd docs && npx serve",
|
||||
"docs-publish": "cd docs && npx firebase-tools deploy --project pixelplumbing --only hosting:pixelplumbing-sharp"
|
||||
},
|
||||
"main": "lib/index.js",
|
||||
"types": "lib/index.d.ts",
|
||||
"files": [
|
||||
"binding.gyp",
|
||||
"install/**",
|
||||
@ -139,6 +141,7 @@
|
||||
"tunnel-agent": "^0.6.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "*",
|
||||
"async": "^3.2.4",
|
||||
"cc": "^3.0.1",
|
||||
"exif-reader": "^1.1.0",
|
||||
@ -151,7 +154,8 @@
|
||||
"nyc": "^15.1.0",
|
||||
"prebuild": "^11.0.4",
|
||||
"rimraf": "^3.0.2",
|
||||
"semistandard": "^16.0.1"
|
||||
"semistandard": "^16.0.1",
|
||||
"tsd": "^0.24.1"
|
||||
},
|
||||
"license": "Apache-2.0",
|
||||
"config": {
|
||||
@ -193,5 +197,8 @@
|
||||
"filter": [
|
||||
"build/include"
|
||||
]
|
||||
},
|
||||
"tsd": {
|
||||
"directory": "test/types/"
|
||||
}
|
||||
}
|
||||
|
||||
636
test/types/sharp.test-d.ts
Normal file
636
test/types/sharp.test-d.ts
Normal file
@ -0,0 +1,636 @@
|
||||
import sharp = require('../../');
|
||||
|
||||
import { createReadStream, createWriteStream } from 'fs';
|
||||
|
||||
const input: Buffer = Buffer.alloc(0);
|
||||
const readableStream: NodeJS.ReadableStream = createReadStream(input);
|
||||
const writableStream: NodeJS.WritableStream = createWriteStream(input);
|
||||
|
||||
sharp(input)
|
||||
.extractChannel('green')
|
||||
.toFile('input_green.jpg', (err, info) => {
|
||||
// info.channels === 1
|
||||
// input_green.jpg contains the green channel of the input image
|
||||
});
|
||||
|
||||
sharp('3-channel-rgb-input.png')
|
||||
.bandbool(sharp.bool.and)
|
||||
.toFile('1-channel-output.png', (err, info) => {
|
||||
// The output will be a single channel image where each pixel `P = R & G & B`.
|
||||
// If `I(1,1) = [247, 170, 14] = [0b11110111, 0b10101010, 0b00001111]`
|
||||
// then `O(1,1) = 0b11110111 & 0b10101010 & 0b00001111 = 0b00000010 = 2`.
|
||||
});
|
||||
|
||||
sharp('input.png')
|
||||
.rotate(180)
|
||||
.resize(300)
|
||||
.flatten({ background: '#ff6600' })
|
||||
.composite([{ input: 'overlay.png', gravity: sharp.gravity.southeast, animated: false, failOn: 'warning' }])
|
||||
.sharpen()
|
||||
.withMetadata()
|
||||
.withMetadata({
|
||||
density: 96,
|
||||
orientation: 8,
|
||||
icc: 'some/path',
|
||||
exif: { IFD0: { Copyright: 'Wernham Hogg' } },
|
||||
})
|
||||
.webp({
|
||||
quality: 90,
|
||||
})
|
||||
.toBuffer()
|
||||
.then((outputBuffer: Buffer) => {
|
||||
// outputBuffer contains upside down, 300px wide, alpha channel flattened
|
||||
// onto orange background, composited with overlay.png with SE gravity,
|
||||
// sharpened, with metadata, 90% quality WebP image data. Phew!
|
||||
});
|
||||
|
||||
sharp('input.jpg')
|
||||
.resize(300, 200)
|
||||
.toFile('output.jpg', (err: Error) => {
|
||||
// output.jpg is a 300 pixels wide and 200 pixels high image
|
||||
// containing a scaled and cropped version of input.jpg
|
||||
});
|
||||
|
||||
sharp('input.jpg').resize({ width: 300 }).blur(false).blur(true).toFile('output.jpg');
|
||||
|
||||
sharp({
|
||||
create: {
|
||||
width: 300,
|
||||
height: 200,
|
||||
channels: 4,
|
||||
background: { r: 255, g: 0, b: 0, alpha: 128 },
|
||||
},
|
||||
})
|
||||
.png()
|
||||
.toBuffer();
|
||||
|
||||
let transformer = sharp()
|
||||
.resize(300)
|
||||
.on('info', (info: sharp.OutputInfo) => {
|
||||
console.log('Image height is ' + info.height);
|
||||
});
|
||||
readableStream.pipe(transformer).pipe(writableStream);
|
||||
|
||||
console.log(sharp.format);
|
||||
console.log(sharp.versions);
|
||||
console.log(sharp.vendor.current);
|
||||
console.log(sharp.vendor.installed.join(', '));
|
||||
|
||||
sharp.queue.on('change', (queueLength: number) => {
|
||||
console.log(`Queue contains ${queueLength} task(s)`);
|
||||
});
|
||||
|
||||
let pipeline: sharp.Sharp = sharp().rotate();
|
||||
pipeline.clone().resize(800, 600).pipe(writableStream);
|
||||
pipeline.clone().extract({ left: 20, top: 20, width: 100, height: 100 }).pipe(writableStream);
|
||||
readableStream.pipe(pipeline);
|
||||
// firstWritableStream receives auto-rotated, resized readableStream
|
||||
// secondWritableStream receives auto-rotated, extracted region of readableStream
|
||||
|
||||
const image: sharp.Sharp = sharp(input);
|
||||
image
|
||||
.metadata()
|
||||
.then<Buffer | undefined>((metadata: sharp.Metadata) => {
|
||||
if (metadata.width) {
|
||||
return image
|
||||
.resize(Math.round(metadata.width / 2))
|
||||
.webp()
|
||||
.toBuffer();
|
||||
}
|
||||
})
|
||||
.then((data) => {
|
||||
// data contains a WebP image half the width and height of the original JPEG
|
||||
});
|
||||
|
||||
pipeline = sharp()
|
||||
.rotate()
|
||||
.resize(undefined, 200)
|
||||
.toBuffer((err: Error, outputBuffer: Buffer, info: sharp.OutputInfo) => {
|
||||
// outputBuffer contains 200px high JPEG image data,
|
||||
// auto-rotated using EXIF Orientation tag
|
||||
// info.width and info.height contain the dimensions of the resized image
|
||||
});
|
||||
readableStream.pipe(pipeline);
|
||||
|
||||
sharp(input)
|
||||
.extract({ left: 0, top: 0, width: 100, height: 100 })
|
||||
.toFile('output', (err: Error) => {
|
||||
// Extract a region of the input image, saving in the same format.
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.extract({ left: 0, top: 0, width: 100, height: 100 })
|
||||
.resize(200, 200)
|
||||
.extract({ left: 0, top: 0, width: 100, height: 100 })
|
||||
.toFile('output', (err: Error) => {
|
||||
// Extract a region, resize, then extract from the resized image
|
||||
});
|
||||
|
||||
// Resize to 140 pixels wide, then add 10 transparent pixels
|
||||
// to the top, left and right edges and 20 to the bottom edge
|
||||
sharp(input)
|
||||
.resize(140, null, { background: { r: 0, g: 0, b: 0, alpha: 0 } })
|
||||
.extend({ top: 10, bottom: 20, left: 10, right: 10 });
|
||||
|
||||
sharp(input)
|
||||
.convolve({
|
||||
width: 3,
|
||||
height: 3,
|
||||
kernel: [-1, 0, 1, -2, 0, 2, -1, 0, 1],
|
||||
})
|
||||
.raw()
|
||||
.toBuffer((err: Error, data: Buffer, info: sharp.OutputInfo) => {
|
||||
// data contains the raw pixel data representing the convolution
|
||||
// of the input image with the horizontal Sobel operator
|
||||
});
|
||||
|
||||
sharp('input.tiff')
|
||||
.png()
|
||||
.tile({
|
||||
size: 512,
|
||||
})
|
||||
.toFile('output.dz', (err: Error, info: sharp.OutputInfo) => {
|
||||
// output.dzi is the Deep Zoom XML definition
|
||||
// output_files contains 512x512 tiles grouped by zoom level
|
||||
});
|
||||
|
||||
sharp('input.tiff')
|
||||
.png()
|
||||
.tile({
|
||||
size: 512,
|
||||
center: true,
|
||||
layout: 'iiif3',
|
||||
id: 'https://my.image.host/iiif',
|
||||
})
|
||||
.toFile('output');
|
||||
|
||||
sharp(input)
|
||||
.resize(200, 300, {
|
||||
fit: 'contain',
|
||||
position: 'north',
|
||||
kernel: sharp.kernel.lanczos2,
|
||||
background: 'white',
|
||||
})
|
||||
.toFile('output.tiff')
|
||||
.then(() => {
|
||||
// output.tiff is a 200 pixels wide and 300 pixels high image
|
||||
// containing a lanczos2/nohalo scaled version, embedded on a white canvas,
|
||||
// of the image data in inputBuffer
|
||||
});
|
||||
|
||||
transformer = sharp()
|
||||
.resize(200, 200, {
|
||||
fit: 'cover',
|
||||
position: sharp.strategy.entropy,
|
||||
})
|
||||
.on('error', (err: Error) => {
|
||||
console.log(err);
|
||||
});
|
||||
// Read image data from readableStream
|
||||
// Write 200px square auto-cropped image data to writableStream
|
||||
readableStream.pipe(transformer).pipe(writableStream);
|
||||
|
||||
sharp('input.gif')
|
||||
.resize(200, 300, {
|
||||
fit: 'contain',
|
||||
position: 'north',
|
||||
background: { r: 0, g: 0, b: 0, alpha: 0 },
|
||||
})
|
||||
.toFormat(sharp.format.webp)
|
||||
.toBuffer((err: Error, outputBuffer: Buffer) => {
|
||||
if (err) {
|
||||
throw err;
|
||||
}
|
||||
// outputBuffer contains WebP image data of a 200 pixels wide and 300 pixels high
|
||||
// containing a scaled version, embedded on a transparent canvas, of input.gif
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.resize(200, 200, { fit: 'inside' })
|
||||
.toFormat('jpeg')
|
||||
.toBuffer()
|
||||
.then((outputBuffer: Buffer) => {
|
||||
// outputBuffer contains JPEG image data no wider than 200 pixels and no higher
|
||||
// than 200 pixels regardless of the inputBuffer image dimensions
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.resize(100, 100)
|
||||
.toFormat('jpg')
|
||||
.toBuffer({ resolveWithObject: false })
|
||||
.then((outputBuffer: Buffer) => {
|
||||
// Resolves with a Buffer object when resolveWithObject is false
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.resize(100, 100)
|
||||
.toBuffer({ resolveWithObject: true })
|
||||
.then((object: { data: Buffer; info: sharp.OutputInfo }) => {
|
||||
// Resolve with an object containing data Buffer and an OutputInfo object
|
||||
// when resolveWithObject is true
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.resize(640, 480, { withoutEnlargement: true })
|
||||
.toFormat('jpeg')
|
||||
.toBuffer()
|
||||
.then((outputBuffer: Buffer) => {
|
||||
// outputBuffer contains JPEG image data no larger than the input
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.resize(640, 480, { withoutReduction: true })
|
||||
.toFormat('jpeg')
|
||||
.toBuffer()
|
||||
.then((outputBuffer: Buffer) => {
|
||||
// outputBuffer contains JPEG image data no smaller than the input
|
||||
});
|
||||
|
||||
// Output to tif
|
||||
sharp(input)
|
||||
.resize(100, 100)
|
||||
.toFormat('tif')
|
||||
.toFormat('tiff')
|
||||
.toFormat(sharp.format.tif)
|
||||
.toFormat(sharp.format.tiff)
|
||||
.toBuffer();
|
||||
|
||||
const stats = sharp.cache();
|
||||
|
||||
sharp.cache({ items: 200 });
|
||||
sharp.cache({ files: 0 });
|
||||
sharp.cache(false);
|
||||
|
||||
const threads = sharp.concurrency(); // 4
|
||||
sharp.concurrency(2); // 2
|
||||
sharp.concurrency(0); // 4
|
||||
|
||||
const counters = sharp.counters(); // { queue: 2, process: 4 }
|
||||
|
||||
let simd: boolean = sharp.simd();
|
||||
// simd is `true` if SIMD is currently enabled
|
||||
|
||||
simd = sharp.simd(true);
|
||||
// attempts to enable the use of SIMD, returning true if available
|
||||
|
||||
const vipsVersion: string = sharp.versions.vips;
|
||||
|
||||
if (sharp.versions.cairo) {
|
||||
const cairoVersion: string = sharp.versions.cairo;
|
||||
}
|
||||
|
||||
sharp('input.gif')
|
||||
.linear(1)
|
||||
.linear(1, 0)
|
||||
.linear(null, 0)
|
||||
.linear([0.25, 0.5, 0.75], [150, 100, 50])
|
||||
|
||||
.recomb([
|
||||
[0.3588, 0.7044, 0.1368],
|
||||
[0.299, 0.587, 0.114],
|
||||
[0.2392, 0.4696, 0.0912],
|
||||
])
|
||||
|
||||
.modulate({ brightness: 2 })
|
||||
.modulate({ hue: 180 })
|
||||
.modulate({ lightness: 10 })
|
||||
.modulate({ brightness: 0.5, saturation: 0.5, hue: 90 });
|
||||
|
||||
// From https://sharp.pixelplumbing.com/api-output#examples-9
|
||||
// Extract raw RGB pixel data from JPEG input
|
||||
sharp('input.jpg')
|
||||
.raw()
|
||||
.toBuffer({ resolveWithObject: true })
|
||||
.then(({ data, info }) => {
|
||||
console.log(data);
|
||||
console.log(info);
|
||||
});
|
||||
|
||||
sharp(input).jpeg().jpeg({}).jpeg({
|
||||
progressive: false,
|
||||
chromaSubsampling: '4:4:4',
|
||||
trellisQuantisation: false,
|
||||
overshootDeringing: false,
|
||||
optimiseScans: false,
|
||||
optimizeScans: false,
|
||||
optimiseCoding: false,
|
||||
optimizeCoding: false,
|
||||
quantisationTable: 10,
|
||||
quantizationTable: 10,
|
||||
mozjpeg: false,
|
||||
quality: 10,
|
||||
force: false,
|
||||
});
|
||||
|
||||
sharp(input).png().png({}).png({
|
||||
progressive: false,
|
||||
compressionLevel: 10,
|
||||
adaptiveFiltering: false,
|
||||
force: false,
|
||||
quality: 10,
|
||||
palette: false,
|
||||
colours: 10,
|
||||
colors: 10,
|
||||
dither: 10,
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.avif()
|
||||
.avif({})
|
||||
.avif({ quality: 50, lossless: false, effort: 5, chromaSubsampling: '4:2:0' })
|
||||
.heif()
|
||||
.heif({})
|
||||
.heif({ quality: 50, compression: 'hevc', lossless: false, effort: 5, chromaSubsampling: '4:2:0' })
|
||||
.toBuffer({ resolveWithObject: true })
|
||||
.then(({ data, info }) => {
|
||||
console.log(data);
|
||||
console.log(info);
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.gif()
|
||||
.gif({})
|
||||
.gif({ loop: 0, delay: [], force: true })
|
||||
.gif({ delay: 30 })
|
||||
.gif({ reoptimise: true })
|
||||
.gif({ reoptimize: false })
|
||||
.toBuffer({ resolveWithObject: true })
|
||||
.then(({ data, info }) => {
|
||||
console.log(data);
|
||||
console.log(info);
|
||||
});
|
||||
|
||||
sharp(input)
|
||||
.tiff({ compression: 'packbits' })
|
||||
.toBuffer({ resolveWithObject: true })
|
||||
.then(({ data, info }) => {
|
||||
console.log(data);
|
||||
console.log(info);
|
||||
});
|
||||
|
||||
sharp('input.jpg')
|
||||
.stats()
|
||||
.then(stats => {
|
||||
const {
|
||||
sharpness,
|
||||
dominant: { r, g, b },
|
||||
} = stats;
|
||||
console.log(sharpness);
|
||||
console.log(`${r}, ${g}, ${b}`);
|
||||
});
|
||||
|
||||
// From https://sharp.pixelplumbing.com/api-output#examples-9
|
||||
// Extract alpha channel as raw pixel data from PNG input
|
||||
sharp('input.png').ensureAlpha().ensureAlpha(0).extractChannel(3).toColourspace('b-w').raw().toBuffer();
|
||||
|
||||
// From https://sharp.pixelplumbing.com/api-constructor#examples-4
|
||||
// Convert an animated GIF to an animated WebP
|
||||
sharp('in.gif', { animated: true }).toFile('out.webp');
|
||||
|
||||
// From https://github.com/lovell/sharp/issues/2701
|
||||
// Type support for limitInputPixels
|
||||
sharp({
|
||||
create: {
|
||||
background: 'red',
|
||||
channels: 4,
|
||||
height: 25000,
|
||||
width: 25000,
|
||||
},
|
||||
limitInputPixels: false,
|
||||
})
|
||||
.toFormat('png')
|
||||
.toBuffer()
|
||||
.then(largeImage => sharp(input).composite([{ input: largeImage, limitInputPixels: false }]));
|
||||
|
||||
// Taken from API documentation at
|
||||
// https://sharp.pixelplumbing.com/api-operation#clahe
|
||||
// introducted
|
||||
sharp('input.jpg').clahe({ width: 10, height: 10 }).toFile('output.jpg');
|
||||
|
||||
sharp('input.jpg').clahe({ width: 10, height: 10, maxSlope: 5 }).toFile('outfile.jpg');
|
||||
|
||||
// Support `unlimited` input option
|
||||
sharp('input.png', { unlimited: true }).resize(320, 240).toFile('outfile.png');
|
||||
|
||||
// Support `subifd` input option for tiffs
|
||||
sharp('input.tiff', { subifd: 3 }).resize(320, 240).toFile('outfile.png');
|
||||
|
||||
// Support creating with noise
|
||||
sharp({
|
||||
create: {
|
||||
background: 'red',
|
||||
channels: 4,
|
||||
height: 100,
|
||||
width: 100,
|
||||
noise: {
|
||||
type: 'gaussian',
|
||||
mean: 128,
|
||||
sigma: 30,
|
||||
},
|
||||
},
|
||||
})
|
||||
.png()
|
||||
.toFile('output.png');
|
||||
|
||||
sharp(new Uint8Array(input.buffer)).toFile('output.jpg');
|
||||
|
||||
// Support for negate options
|
||||
sharp('input.png').negate({ alpha: false }).toFile('output.png');
|
||||
|
||||
// From https://github.com/lovell/sharp/pull/2704
|
||||
// Type support for pipelineColourspace
|
||||
sharp(input)
|
||||
.pipelineColourspace('rgb16')
|
||||
.resize(320, 240)
|
||||
.gamma()
|
||||
.toColourspace('srgb') // this is the default, but included here for clarity
|
||||
.toBuffer();
|
||||
|
||||
// From https://github.com/lovell/sharp/pull/1439
|
||||
// Second parameter to gamma operation for different output gamma
|
||||
sharp(input)
|
||||
.resize(129, 111)
|
||||
.gamma(2.2, 3.0)
|
||||
.toBuffer(err => {
|
||||
if (err) throw err;
|
||||
});
|
||||
|
||||
// Support for raw depth specification
|
||||
sharp('16bpc.png')
|
||||
.toColourspace('rgb16')
|
||||
.raw({ depth: 'ushort' })
|
||||
.toBuffer((error, data, { width, height, channels, size }) => {
|
||||
console.log((size / width / height / channels) * 8);
|
||||
console.log(new Uint16Array(data.buffer));
|
||||
});
|
||||
|
||||
// Output channels are constrained from 1-4, can be used as raw input
|
||||
sharp(input)
|
||||
.toBuffer({ resolveWithObject: true })
|
||||
.then(result => {
|
||||
const newImg = sharp(result.data, {
|
||||
raw: {
|
||||
channels: result.info.channels,
|
||||
width: result.info.width,
|
||||
height: result.info.height,
|
||||
},
|
||||
});
|
||||
|
||||
return newImg.toBuffer();
|
||||
});
|
||||
|
||||
// Support for specifying a timeout
|
||||
sharp('someImage.png').timeout({ seconds: 30 }).resize(300, 300).toBuffer();
|
||||
|
||||
// Support for `effort` in different formats
|
||||
sharp('input.tiff').png({ effort: 9 }).toFile('out.png');
|
||||
sharp('input.tiff').webp({ effort: 9 }).toFile('out.webp');
|
||||
sharp('input.tiff').avif({ effort: 9 }).toFile('out.avif');
|
||||
sharp('input.tiff').heif({ effort: 9 }).toFile('out.heif');
|
||||
sharp('input.tiff').gif({ effort: 9 }).toFile('out.gif');
|
||||
|
||||
// Support for `colors`/`colours` for gif output
|
||||
sharp('input.gif').gif({ colors: 16 }).toFile('out.gif');
|
||||
sharp('input.gif').gif({ colours: 16 }).toFile('out.gif');
|
||||
|
||||
// Support for `dither` for gif/png output
|
||||
sharp('input.gif').gif({ dither: 0.5 }).toFile('out.gif');
|
||||
sharp('input.gif').png({ dither: 0.5 }).toFile('out.png');
|
||||
|
||||
// Support for `interFrameMaxError` for gif output
|
||||
sharp('input.gif').gif({ interFrameMaxError: 0 }).toFile('out.gif');
|
||||
|
||||
// Support for `interPaletteMaxError` for gif output
|
||||
sharp('input.gif').gif({ interPaletteMaxError: 0 }).toFile('out.gif');
|
||||
|
||||
// Support for `resolutionUnit` for tiff output
|
||||
sharp('input.tiff').tiff({ resolutionUnit: 'cm' }).toFile('out.tiff');
|
||||
|
||||
// Support for `jp2` output with different options
|
||||
sharp('input.tiff').jp2().toFile('out.jp2');
|
||||
sharp('input.tiff').jp2({ quality: 50 }).toFile('out.jp2');
|
||||
sharp('input.tiff').jp2({ lossless: true }).toFile('out.jp2');
|
||||
sharp('input.tiff').jp2({ tileWidth: 128, tileHeight: 128 }).toFile('out.jp2');
|
||||
sharp('input.tiff').jp2({ chromaSubsampling: '4:2:0' }).toFile('out.jp2');
|
||||
|
||||
// Support for `jxl` output with different options
|
||||
sharp('input.tiff').jxl().toFile('out.jxl');
|
||||
sharp('input.tiff').jxl({ distance: 15.0 }).toFile('out.jxl');
|
||||
sharp('input.tiff').jxl({ quality: 50 }).toFile('out.jxl');
|
||||
sharp('input.tiff').jxl({ decodingTier: 4 }).toFile('out.jxl');
|
||||
sharp('input.tiff').jxl({ lossless: true }).toFile('out.jxl');
|
||||
sharp('input.tiff').jxl({ effort: 7 }).toFile('out.jxl');
|
||||
|
||||
// Support `minSize` and `mixed` webp options
|
||||
sharp('input.tiff').webp({ minSize: 1000, mixed: true }).toFile('out.gif');
|
||||
|
||||
// 'failOn' input param
|
||||
sharp('input.tiff', { failOn: 'none' });
|
||||
sharp('input.tiff', { failOn: 'truncated' });
|
||||
sharp('input.tiff', { failOn: 'error' });
|
||||
sharp('input.tiff', { failOn: 'warning' });
|
||||
|
||||
// Sharpen operation taking an object instead of three params
|
||||
sharp('input.tiff').sharpen().toBuffer();
|
||||
sharp('input.tiff').sharpen({ sigma: 2 }).toBuffer();
|
||||
sharp('input.tiff')
|
||||
.sharpen({
|
||||
sigma: 2,
|
||||
m1: 0,
|
||||
m2: 3,
|
||||
x1: 3,
|
||||
y2: 15,
|
||||
y3: 15,
|
||||
})
|
||||
.toBuffer();
|
||||
|
||||
// Affine operator + interpolator hash
|
||||
sharp().affine(
|
||||
[
|
||||
[1, 0.3],
|
||||
[0.1, 0.7],
|
||||
],
|
||||
{
|
||||
background: 'white',
|
||||
interpolator: sharp.interpolators.nohalo,
|
||||
},
|
||||
);
|
||||
|
||||
sharp().affine([1, 1, 1, 1], {
|
||||
background: 'white',
|
||||
idx: 0,
|
||||
idy: 0,
|
||||
odx: 0,
|
||||
ody: 0,
|
||||
});
|
||||
|
||||
const bicubic: string = sharp.interpolators.bicubic;
|
||||
const bilinear: string = sharp.interpolators.bilinear;
|
||||
const locallyBoundedBicubic: string = sharp.interpolators.locallyBoundedBicubic;
|
||||
const nearest: string = sharp.interpolators.nearest;
|
||||
const nohalo: string = sharp.interpolators.nohalo;
|
||||
const vertexSplitQuadraticBasisSpline: string = sharp.interpolators.vertexSplitQuadraticBasisSpline;
|
||||
|
||||
// Triming
|
||||
sharp(input).trim('#000').toBuffer();
|
||||
sharp(input).trim(10).toBuffer();
|
||||
sharp(input).trim({ background: '#bf1942', threshold: 30 }).toBuffer();
|
||||
|
||||
// Text input
|
||||
sharp({
|
||||
text: {
|
||||
text: 'Hello world',
|
||||
align: 'centre',
|
||||
dpi: 72,
|
||||
font: 'Arial',
|
||||
fontfile: 'path/to/arial.ttf',
|
||||
height: 500,
|
||||
width: 500,
|
||||
rgba: true,
|
||||
justify: true,
|
||||
spacing: 10,
|
||||
},
|
||||
})
|
||||
.png()
|
||||
.toBuffer({ resolveWithObject: true })
|
||||
.then(out => {
|
||||
console.log(out.info.textAutofitDpi);
|
||||
});
|
||||
|
||||
// Text composite
|
||||
sharp('input.png').composite([
|
||||
{
|
||||
input: {
|
||||
text: {
|
||||
text: 'Okay then',
|
||||
font: 'Comic Sans',
|
||||
},
|
||||
},
|
||||
},
|
||||
]);
|
||||
|
||||
// From https://github.com/lovell/sharp/pull/1835
|
||||
sharp('input.png').composite([
|
||||
{
|
||||
input: {
|
||||
text: {
|
||||
text: 'Okay then',
|
||||
font: 'Comic Sans',
|
||||
},
|
||||
},
|
||||
blend: 'color-burn',
|
||||
top: 0,
|
||||
left: 0,
|
||||
premultiplied: true,
|
||||
},
|
||||
]);
|
||||
|
||||
// https://github.com/lovell/sharp/pull/402
|
||||
(['fs', 'zip'] as const).forEach(container => {
|
||||
sharp().tile({ container });
|
||||
});
|
||||
|
||||
// From https://github.com/lovell/sharp/issues/2238
|
||||
sharp('input.png').tile({
|
||||
basename: 'output.dz.tiles',
|
||||
});
|
||||
4
test/types/tsconfig.json
Normal file
4
test/types/tsconfig.json
Normal file
@ -0,0 +1,4 @@
|
||||
{
|
||||
"module": "commonjs",
|
||||
"strict": true
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user