fabric 5.3.0 → 6.0.0-beta3

package/dist/src/filters/Saturation.d.ts

@@ -0,0 +1,48 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+/**
+ * Saturate filter class
+ * @example
+ * const filter = new Saturation({
+ *   saturation: 1
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare const saturationDefaultValues: Partial<TClassProperties<Saturation>>;
+export declare class Saturation extends BaseFilter {
+    /**
+     * Saturation value, from -1 to 1.
+     * Increases/decreases the color saturation.
+     * A value of 0 has no effect.
+     *
+     * @param {Number} saturation
+     * @default
+     */
+    saturation: number;
+    static defaults: Partial<TClassProperties<Saturation>>;
+    getFragmentSource(): string;
+    /**
+     * Apply the Saturation operation to a Uint8ClampedArray representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8ClampedArray to be filtered.
+     */
+    applyTo2d({ imageData: { data } }: T2DPipelineState): void;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * Send data from this filter to its shader program's uniforms.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects
+     */
+    sendUniformData(gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+}
+//# sourceMappingURL=Saturation.d.ts.map

package/dist/src/filters/Vibrance.d.ts

@@ -0,0 +1,48 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export declare const vibranceDefaultValues: Partial<TClassProperties<Vibrance>>;
+/**
+ * Vibrance filter class
+ * @example
+ * const filter = new Vibrance({
+ *   vibrance: 1
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Vibrance extends BaseFilter {
+    /**
+     * Vibrance value, from -1 to 1.
+     * Increases/decreases the saturation of more muted colors with less effect on saturated colors.
+     * A value of 0 has no effect.
+     *
+     * @param {Number} vibrance
+     * @default
+     */
+    vibrance: number;
+    static defaults: Partial<TClassProperties<Vibrance>>;
+    getFragmentSource(): string;
+    /**
+     * Apply the Vibrance operation to a Uint8ClampedArray representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8ClampedArray to be filtered.
+     */
+    applyTo2d({ imageData: { data } }: T2DPipelineState): void;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * Send data from this filter to its shader program's uniforms.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects
+     */
+    sendUniformData(gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+}
+//# sourceMappingURL=Vibrance.d.ts.map

package/dist/src/filters/WebGLFilterBackend.d.ts

@@ -0,0 +1,126 @@
+import { TWebGLPipelineState, TProgramCache, TTextureCache, TPipelineResources } from './typedefs';
+export declare class WebGLFilterBackend {
+    tileSize: number;
+    /**
+     * Define ...
+     **/
+    aPosition: Float32Array;
+    /**
+     * If GLPut data is the fastest operation, or if forced, this buffer will be used
+     * to transfer the data back in the 2d logic
+     **/
+    imageBuffer?: ArrayBuffer;
+    canvas: HTMLCanvasElement;
+    /**
+     * The Webgl context that will execute the operations for filtering
+     **/
+    gl: WebGLRenderingContext;
+    /**
+     * Keyed map for shader cache
+     **/
+    programCache: TProgramCache;
+    /**
+     * Keyed map for texture cache
+     **/
+    textureCache: TTextureCache;
+    /**
+     * Contains GPU info for debug
+     **/
+    gpuInfo: any;
+    /**
+     * Experimental. This object is a sort of repository of help layers used to avoid
+     * of recreating them during frequent filtering. If you are previewing a filter with
+     * a slider you probably do not want to create help layers every filter step.
+     * in this object there will be appended some canvases, created once, resized sometimes
+     * cleared never. Clearing is left to the developer.
+     **/
+    resources: TPipelineResources;
+    constructor({ tileSize }?: {
+        tileSize?: number | undefined;
+    });
+    /**
+     * Setup a WebGL context suitable for filtering, and bind any needed event handlers.
+     */
+    setupGLContext(width: number, height: number): void;
+    /**
+     * Pick a method to copy data from GL context to 2d canvas.  In some browsers using
+     * drawImage should be faster, but is also bugged for a small combination of old hardware
+     * and drivers.
+     * putImageData is faster than drawImage for that specific operation.
+     */
+    chooseFastestCopyGLTo2DMethod(width: number, height: number): void;
+    /**
+     * Create a canvas element and associated WebGL context and attaches them as
+     * class properties to the GLFilterBackend class.
+     */
+    createWebGLCanvas(width: number, height: number): void;
+    /**
+     * Attempts to apply the requested filters to the source provided, drawing the filtered output
+     * to the provided target canvas.
+     *
+     * @param {Array} filters The filters to apply.
+     * @param {TexImageSource} source The source to be filtered.
+     * @param {Number} width The width of the source input.
+     * @param {Number} height The height of the source input.
+     * @param {HTMLCanvasElement} targetCanvas The destination for filtered output to be drawn.
+     * @param {String|undefined} cacheKey A key used to cache resources related to the source. If
+     * omitted, caching will be skipped.
+     */
+    applyFilters(filters: any[], source: TexImageSource, width: number, height: number, targetCanvas: HTMLCanvasElement, cacheKey?: string): TWebGLPipelineState | undefined;
+    /**
+     * Detach event listeners, remove references, and clean up caches.
+     */
+    dispose(): void;
+    /**
+     * Wipe out WebGL-related caches.
+     */
+    clearWebGLCaches(): void;
+    /**
+     * Create a WebGL texture object.
+     *
+     * Accepts specific dimensions to initialize the texture to or a source image.
+     *
+     * @param {WebGLRenderingContext} gl The GL context to use for creating the texture.
+     * @param {Number} width The width to initialize the texture at.
+     * @param {Number} height The height to initialize the texture.
+     * @param {HTMLImageElement|HTMLCanvasElement} textureImageSource A source for the texture data.
+     * @returns {WebGLTexture}
+     */
+    createTexture(gl: WebGLRenderingContext, width: number, height: number, textureImageSource?: TexImageSource): WebGLTexture | null;
+    /**
+     * Can be optionally used to get a texture from the cache array
+     *
+     * If an existing texture is not found, a new texture is created and cached.
+     *
+     * @param {String} uniqueId A cache key to use to find an existing texture.
+     * @param {HTMLImageElement|HTMLCanvasElement} textureImageSource A source to use to create the
+     * texture cache entry if one does not already exist.
+     */
+    getCachedTexture(uniqueId: string, textureImageSource: TexImageSource): any;
+    /**
+     * Clear out cached resources related to a source image that has been
+     * filtered previously.
+     *
+     * @param {String} cacheKey The cache key provided when the source image was filtered.
+     */
+    evictCachesForKey(cacheKey: string): void;
+    /**
+     * Copy an input WebGL canvas on to an output 2D canvas.
+     *
+     * The WebGL canvas is assumed to be upside down, with the top-left pixel of the
+     * desired output image appearing in the bottom-left corner of the WebGL canvas.
+     *
+     * @param {WebGLRenderingContext} sourceContext The WebGL context to copy from.
+     * @param {Object} pipelineState The 2D target canvas to copy on to.
+     */
+    copyGLTo2D(gl: WebGLRenderingContext, pipelineState: TWebGLPipelineState): void;
+    /**
+     * Attempt to extract GPU information strings from a WebGL context.
+     *
+     * Useful information when debugging or blacklisting specific GPUs.
+     *
+     * @returns {Object} A GPU info object with renderer and vendor strings.
+     */
+    captureGPUInfo(): any;
+}
+//# sourceMappingURL=WebGLFilterBackend.d.ts.map

package/dist/src/filters/filters.d.ts

@@ -0,0 +1,21 @@
+export { BaseFilter } from './BaseFilter';
+export { BlendColor } from './BlendColor';
+export { BlendImage } from './BlendImage';
+export { Blur } from './Blur';
+export { Brightness } from './Brightness';
+export { ColorMatrix } from './ColorMatrix';
+export { BlackWhite, Brownie, Kodachrome, Polaroid, Sepia, Technicolor, Vintage, } from './ColorMatrixFilters';
+export { Composed } from './Composed';
+export { Contrast } from './Contrast';
+export { Convolute } from './Convolute';
+export { Gamma } from './Gamma';
+export { Grayscale } from './Grayscale';
+export { HueRotation } from './HueRotation';
+export { Invert } from './Invert';
+export { Noise } from './Noise';
+export { Pixelate } from './Pixelate';
+export { RemoveColor } from './RemoveColor';
+export { Resize } from './Resize';
+export { Saturation } from './Saturation';
+export { Vibrance } from './Vibrance';
+//# sourceMappingURL=filters.d.ts.map

package/dist/src/filters/index.d.ts

@@ -0,0 +1,5 @@
+export * as filters from './filters';
+export { getFilterBackend, initFilterBackend } from './FilterBackend';
+export { Canvas2dFilterBackend } from './Canvas2dFilterBackend';
+export { WebGLFilterBackend } from './WebGLFilterBackend';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/filters/shaders/baseFilter.d.ts

@@ -0,0 +1,4 @@
+export declare const highPsourceCode: string;
+export declare const identityFragmentShader: string;
+export declare const vertexSource = "\n    attribute vec2 aPosition;\n    varying vec2 vTexCoord;\n    void main() {\n      vTexCoord = aPosition;\n      gl_Position = vec4(aPosition * 2.0 - 1.0, 0.0, 1.0);\n    }";
+//# sourceMappingURL=baseFilter.d.ts.map

package/dist/src/filters/shaders/blendColor.d.ts

@@ -0,0 +1,13 @@
+export declare const blendColorFragmentSource: {
+    readonly multiply: "gl_FragColor.rgb *= uColor.rgb;\n";
+    readonly screen: "gl_FragColor.rgb = 1.0 - (1.0 - gl_FragColor.rgb) * (1.0 - uColor.rgb);\n";
+    readonly add: "gl_FragColor.rgb += uColor.rgb;\n";
+    readonly difference: "gl_FragColor.rgb = abs(gl_FragColor.rgb - uColor.rgb);\n";
+    readonly subtract: "gl_FragColor.rgb -= uColor.rgb;\n";
+    readonly lighten: "gl_FragColor.rgb = max(gl_FragColor.rgb, uColor.rgb);\n";
+    readonly darken: "gl_FragColor.rgb = min(gl_FragColor.rgb, uColor.rgb);\n";
+    readonly exclusion: "gl_FragColor.rgb += uColor.rgb - 2.0 * (uColor.rgb * gl_FragColor.rgb);\n";
+    readonly overlay: "\n    if (uColor.r < 0.5) {\n      gl_FragColor.r *= 2.0 * uColor.r;\n    } else {\n      gl_FragColor.r = 1.0 - 2.0 * (1.0 - gl_FragColor.r) * (1.0 - uColor.r);\n    }\n    if (uColor.g < 0.5) {\n      gl_FragColor.g *= 2.0 * uColor.g;\n    } else {\n      gl_FragColor.g = 1.0 - 2.0 * (1.0 - gl_FragColor.g) * (1.0 - uColor.g);\n    }\n    if (uColor.b < 0.5) {\n      gl_FragColor.b *= 2.0 * uColor.b;\n    } else {\n      gl_FragColor.b = 1.0 - 2.0 * (1.0 - gl_FragColor.b) * (1.0 - uColor.b);\n    }\n    ";
+    readonly tint: "\n    gl_FragColor.rgb *= (1.0 - uColor.a);\n    gl_FragColor.rgb += uColor.rgb;\n    ";
+};
+//# sourceMappingURL=blendColor.d.ts.map

package/dist/src/filters/shaders/blendImage.d.ts

@@ -0,0 +1,3 @@
+import { TBlendImageMode } from '../BlendImage';
+export declare const fragmentSource: Record<TBlendImageMode, string>;
+//# sourceMappingURL=blendImage.d.ts.map

package/dist/src/filters/shaders/blur.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource: "\n    precision highp float;\n    uniform sampler2D uTexture;\n    uniform vec2 uDelta;\n    varying vec2 vTexCoord;\n    const float nSamples = 15.0;\n    vec3 v3offset = vec3(12.9898, 78.233, 151.7182);\n    float random(vec3 scale) {\n      /* use the fragment position for a different seed per-pixel */\n      return fract(sin(dot(gl_FragCoord.xyz, scale)) * 43758.5453);\n    }\n    void main() {\n      vec4 color = vec4(0.0);\n      float total = 0.0;\n      float offset = random(v3offset);\n      for (float t = -nSamples; t <= nSamples; t++) {\n        float percent = (t + offset - 0.5) / nSamples;\n        float weight = 1.0 - abs(percent);\n        color += texture2D(uTexture, vTexCoord + uDelta * percent) * weight;\n        total += weight;\n      }\n      gl_FragColor = color / total;\n    }\n  ";
+//# sourceMappingURL=blur.d.ts.map

package/dist/src/filters/shaders/brightness.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform float uBrightness;\n  varying vec2 vTexCoord;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    color.rgb += uBrightness;\n    gl_FragColor = color;\n  }\n";
+//# sourceMappingURL=brightness.d.ts.map

package/dist/src/filters/shaders/colorMatrix.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  varying vec2 vTexCoord;\n  uniform mat4 uColorMatrix;\n  uniform vec4 uConstants;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    color *= uColorMatrix;\n    color += uConstants;\n    gl_FragColor = color;\n  }";
+//# sourceMappingURL=colorMatrix.d.ts.map

package/dist/src/filters/shaders/constrast.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform float uContrast;\n  varying vec2 vTexCoord;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    float contrastF = 1.015 * (uContrast + 1.0) / (1.0 * (1.015 - uContrast));\n    color.rgb = contrastF * (color.rgb - 0.5) + 0.5;\n    gl_FragColor = color;\n  }";
+//# sourceMappingURL=constrast.d.ts.map

package/dist/src/filters/shaders/convolute.d.ts

@@ -0,0 +1,11 @@
+export declare const fragmentSource: {
+    Convolute_3_1: string;
+    Convolute_3_0: string;
+    Convolute_5_1: string;
+    Convolute_5_0: string;
+    Convolute_7_1: string;
+    Convolute_7_0: string;
+    Convolute_9_1: string;
+    Convolute_9_0: string;
+};
+//# sourceMappingURL=convolute.d.ts.map

package/dist/src/filters/shaders/gamma.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform vec3 uGamma;\n  varying vec2 vTexCoord;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    vec3 correction = (1.0 / uGamma);\n    color.r = pow(color.r, correction.r);\n    color.g = pow(color.g, correction.g);\n    color.b = pow(color.b, correction.b);\n    gl_FragColor = color;\n    gl_FragColor.rgb *= color.a;\n  }\n";
+//# sourceMappingURL=gamma.d.ts.map

package/dist/src/filters/shaders/grayscale.d.ts

@@ -0,0 +1,3 @@
+import { TGrayscaleMode } from '../Grayscale';
+export declare const fragmentSource: Record<TGrayscaleMode, string>;
+//# sourceMappingURL=grayscale.d.ts.map

package/dist/src/filters/shaders/invert.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform int uInvert;\n  uniform int uAlpha;\n  varying vec2 vTexCoord;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    if (uInvert == 1) {\n      if (uAlpha == 1) {\n        gl_FragColor = vec4(1.0 - color.r,1.0 -color.g,1.0 -color.b,1.0 -color.a);\n      } else {\n        gl_FragColor = vec4(1.0 - color.r,1.0 -color.g,1.0 -color.b,color.a);\n      }\n    } else {\n      gl_FragColor = color;\n    }\n  }\n";
+//# sourceMappingURL=invert.d.ts.map

package/dist/src/filters/shaders/noise.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform float uStepH;\n  uniform float uNoise;\n  uniform float uSeed;\n  varying vec2 vTexCoord;\n  float rand(vec2 co, float seed, float vScale) {\n    return fract(sin(dot(co.xy * vScale ,vec2(12.9898 , 78.233))) * 43758.5453 * (seed + 0.01) / 2.0);\n  }\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    color.rgb += (0.5 - rand(vTexCoord, uSeed, 0.1 / uStepH)) * uNoise;\n    gl_FragColor = color;\n  }\n";
+//# sourceMappingURL=noise.d.ts.map

package/dist/src/filters/shaders/pixelate.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform float uBlocksize;\n  uniform float uStepW;\n  uniform float uStepH;\n  varying vec2 vTexCoord;\n  void main() {\n    float blockW = uBlocksize * uStepW;\n    float blockH = uBlocksize * uStepW;\n    int posX = int(vTexCoord.x / blockW);\n    int posY = int(vTexCoord.y / blockH);\n    float fposX = float(posX);\n    float fposY = float(posY);\n    vec2 squareCoords = vec2(fposX * blockW, fposY * blockH);\n    vec4 color = texture2D(uTexture, squareCoords);\n    gl_FragColor = color;\n  }\n";
+//# sourceMappingURL=pixelate.d.ts.map

package/dist/src/filters/shaders/removeColor.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentShader = "\nprecision highp float;\nuniform sampler2D uTexture;\nuniform vec4 uLow;\nuniform vec4 uHigh;\nvarying vec2 vTexCoord;\nvoid main() {\n  gl_FragColor = texture2D(uTexture, vTexCoord);\n  if(all(greaterThan(gl_FragColor.rgb,uLow.rgb)) && all(greaterThan(uHigh.rgb,gl_FragColor.rgb))) {\n    gl_FragColor.a = 0.0;\n  }\n}\n";
+//# sourceMappingURL=removeColor.d.ts.map

package/dist/src/filters/shaders/saturation.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform float uSaturation;\n  varying vec2 vTexCoord;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    float rgMax = max(color.r, color.g);\n    float rgbMax = max(rgMax, color.b);\n    color.r += rgbMax != color.r ? (rgbMax - color.r) * uSaturation : 0.00;\n    color.g += rgbMax != color.g ? (rgbMax - color.g) * uSaturation : 0.00;\n    color.b += rgbMax != color.b ? (rgbMax - color.b) * uSaturation : 0.00;\n    gl_FragColor = color;\n  }\n";
+//# sourceMappingURL=saturation.d.ts.map

package/dist/src/filters/shaders/vibrance.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform float uVibrance;\n  varying vec2 vTexCoord;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    float max = max(color.r, max(color.g, color.b));\n    float avg = (color.r + color.g + color.b) / 3.0;\n    float amt = (abs(max - avg) * 2.0) * uVibrance;\n    color.r += max != color.r ? (max - color.r) * amt : 0.00;\n    color.g += max != color.g ? (max - color.g) * amt : 0.00;\n    color.b += max != color.b ? (max - color.b) * amt : 0.00;\n    gl_FragColor = color;\n  }\n";
+//# sourceMappingURL=vibrance.d.ts.map

package/dist/src/filters/typedefs.d.ts

@@ -0,0 +1,49 @@
+import type { WebGLFilterBackend } from './WebGLFilterBackend';
+import type { Canvas2dFilterBackend } from './Canvas2dFilterBackend';
+export type TProgramCache = any;
+export type TTextureCache = any;
+export type TPipelineResources = {
+    blendImage?: HTMLCanvasElement;
+    blurLayer1?: HTMLCanvasElement;
+    blurLayer2?: HTMLCanvasElement;
+} & Record<string, unknown>;
+export type TWebGLPipelineState = {
+    filterBackend: WebGLFilterBackend;
+    originalWidth: number;
+    originalHeight: number;
+    sourceWidth: number;
+    sourceHeight: number;
+    destinationWidth: number;
+    destinationHeight: number;
+    context: WebGLRenderingContext;
+    sourceTexture: WebGLTexture | null;
+    targetTexture: WebGLTexture | null;
+    originalTexture: WebGLTexture;
+    passes: number;
+    webgl: boolean;
+    aPosition: Float32Array;
+    programCache: TProgramCache;
+    pass: number;
+    targetCanvas: HTMLCanvasElement;
+};
+export type T2DPipelineState = {
+    sourceWidth: number;
+    sourceHeight: number;
+    filterBackend: Canvas2dFilterBackend;
+    canvasEl: HTMLCanvasElement;
+    imageData: ImageData;
+    originalEl: CanvasImageSource;
+    originalImageData?: ImageData;
+    ctx: CanvasRenderingContext2D;
+    helpLayer?: HTMLCanvasElement;
+};
+export type TWebGLUniformLocationMap = Record<string, WebGLUniformLocation | null>;
+export type TWebGLAttributeLocationMap = Record<string, number>;
+export type TWebGLProgramCacheItem = {
+    program: WebGLProgram;
+    attributeLocations: TWebGLAttributeLocationMap;
+    uniformLocations: TWebGLUniformLocationMap;
+};
+export type TApplyFilterArgs = {};
+export declare const isWebGLPipelineState: (options: TWebGLPipelineState | T2DPipelineState) => options is TWebGLPipelineState;
+//# sourceMappingURL=typedefs.d.ts.map

package/dist/src/gradient/Gradient.d.ts

@@ -0,0 +1,149 @@
+import type { FabricObject } from '../shapes/Object/FabricObject';
+import { TMat2D } from '../typedefs';
+import { ColorStop, GradientCoords, GradientOptions, GradientType, GradientUnits, SVGOptions } from './typedefs';
+/**
+ * Gradient class
+ * @class Gradient
+ * @tutorial {@link http://fabricjs.com/fabric-intro-part-2#gradients}
+ */
+export declare class Gradient<S, T extends GradientType = S extends GradientType ? S : 'linear'> {
+    /**
+     * Horizontal offset for aligning gradients coming from SVG when outside pathgroups
+     * @type Number
+     * @default 0
+     */
+    offsetX: number;
+    /**
+     * Vertical offset for aligning gradients coming from SVG when outside pathgroups
+     * @type Number
+     * @default 0
+     */
+    offsetY: number;
+    /**
+     * A transform matrix to apply to the gradient before painting.
+     * Imported from svg gradients, is not applied with the current transform in the center.
+     * Before this transform is applied, the origin point is at the top left corner of the object
+     * plus the addition of offsetY and offsetX.
+     * @type Number[]
+     * @default null
+     */
+    gradientTransform: TMat2D | null;
+    /**
+     * coordinates units for coords.
+     * If `pixels`, the number of coords are in the same unit of width / height.
+     * If set as `percentage` the coords are still a number, but 1 means 100% of width
+     * for the X and 100% of the height for the y. It can be bigger than 1 and negative.
+     * allowed values pixels or percentage.
+     * @type GradientUnits
+     * @default 'pixels'
+     */
+    gradientUnits: GradientUnits;
+    /**
+     * Gradient type linear or radial
+     * @type GradientType
+     * @default 'linear'
+     */
+    type: T;
+    /**
+     * Defines how the gradient is located in space and spread
+     * @type GradientCoords
+     */
+    coords: GradientCoords<T>;
+    /**
+     * Defines how many colors a gradient has and how they are located on the axis
+     * defined by coords
+     * @type GradientCoords
+     */
+    colorStops: ColorStop[];
+    /**
+     * If true, this object will not be exported during the serialization of a canvas
+     * @type boolean
+     */
+    excludeFromExport?: boolean;
+    /**
+     * ID used for SVG export functionalities
+     * @type number | string
+     */
+    readonly id: string | number;
+    constructor({ type, gradientUnits, coords, colorStops, offsetX, offsetY, gradientTransform, id, }: GradientOptions<T>);
+    /**
+     * Adds another colorStop
+     * @param {Record<string, string>} colorStop Object with offset and color
+     * @return {Gradient} thisArg
+     */
+    addColorStop(colorStops: Record<string, string>): this;
+    /**
+     * Returns object representation of a gradient
+     * @param {string[]} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {object}
+     */
+    toObject(propertiesToInclude?: (keyof this | string)[]): Partial<this> & {
+        type: T;
+        coords: GradientCoords<T>;
+        colorStops: ColorStop[];
+        offsetX: number;
+        offsetY: number;
+        gradientUnits: GradientUnits;
+        gradientTransform: number[] | null;
+    };
+    /**
+     * Returns SVG representation of an gradient
+     * @param {FabricObject} object Object to create a gradient for
+     * @return {String} SVG representation of an gradient (linear/radial)
+     */
+    toSVG(object: FabricObject, { additionalTransform: preTransform }?: {
+        additionalTransform?: string;
+    }): string;
+    /**
+     * Returns an instance of CanvasGradient
+     * @param {CanvasRenderingContext2D} ctx Context to render on
+     * @return {CanvasGradient}
+     */
+    toLive(ctx: CanvasRenderingContext2D): CanvasGradient;
+    /**
+     * Returns {@link Gradient} instance from an SVG element
+     * @static
+     * @memberOf Gradient
+     * @param {SVGGradientElement} el SVG gradient element
+     * @param {FabricObject} instance
+     * @param {String} opacity A fill-opacity or stroke-opacity attribute to multiply to each stop's opacity.
+     * @param {SVGOptions} svgOptions an object containing the size of the SVG in order to parse correctly gradients
+     * that uses gradientUnits as 'userSpaceOnUse' and percentages.
+     * @return {Gradient} Gradient instance
+     * @see http://www.w3.org/TR/SVG/pservers.html#LinearGradientElement
+     * @see http://www.w3.org/TR/SVG/pservers.html#RadialGradientElement
+     *
+     *  @example
+     *
+     *  <linearGradient id="linearGrad1">
+     *    <stop offset="0%" stop-color="white"/>
+     *    <stop offset="100%" stop-color="black"/>
+     *  </linearGradient>
+     *
+     *  OR
+     *
+     *  <linearGradient id="linearGrad2">
+     *    <stop offset="0" style="stop-color:rgb(255,255,255)"/>
+     *    <stop offset="1" style="stop-color:rgb(0,0,0)"/>
+     *  </linearGradient>
+     *
+     *  OR
+     *
+     *  <radialGradient id="radialGrad1">
+     *    <stop offset="0%" stop-color="white" stop-opacity="1" />
+     *    <stop offset="50%" stop-color="black" stop-opacity="0.5" />
+     *    <stop offset="100%" stop-color="white" stop-opacity="1" />
+     *  </radialGradient>
+     *
+     *  OR
+     *
+     *  <radialGradient id="radialGrad2">
+     *    <stop offset="0" stop-color="rgb(255,255,255)" />
+     *    <stop offset="0.5" stop-color="rgb(0,0,0)" />
+     *    <stop offset="1" stop-color="rgb(255,255,255)" />
+     *  </radialGradient>
+     *
+     */
+    static fromElement(el: SVGGradientElement, instance: FabricObject, svgOptions: SVGOptions): Gradient<GradientType>;
+}
+//# sourceMappingURL=Gradient.d.ts.map

package/dist/src/gradient/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const linearDefaultCoords: {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export declare const radialDefaultCoords: {
+    r1: number;
+    r2: number;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/gradient/parser/index.d.ts

@@ -0,0 +1,4 @@
+export * from './misc';
+export * from './parseColorStops';
+export * from './parseCoords';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/gradient/parser/misc.d.ts

@@ -0,0 +1,4 @@
+import { GradientType, GradientUnits } from '../typedefs';
+export declare function parseType(el: SVGGradientElement): GradientType;
+export declare function parseGradientUnits(el: SVGGradientElement): GradientUnits;
+//# sourceMappingURL=misc.d.ts.map

package/dist/src/gradient/parser/parseColorStops.d.ts

@@ -0,0 +1,3 @@
+import { ColorStop } from '../typedefs';
+export declare function parseColorStops(el: SVGGradientElement, opacityAttr: string | null): ColorStop[];
+//# sourceMappingURL=parseColorStops.d.ts.map

package/dist/src/gradient/parser/parseCoords.d.ts

@@ -0,0 +1,17 @@
+import { TSize } from '../../typedefs';
+export declare function parseLinearCoords(el: SVGGradientElement): {
+    x1: string | number;
+    y1: string | number;
+    x2: string;
+    y2: string | number;
+};
+export declare function parseRadialCoords(el: SVGGradientElement): {
+    x1: string;
+    y1: string;
+    r1: number;
+    x2: string;
+    y2: string;
+    r2: string;
+};
+export declare function parseCoords(el: SVGGradientElement, size: TSize): Record<"x1" | "y1" | "x2" | "y2", number>;
+//# sourceMappingURL=parseCoords.d.ts.map