@dxyl/utils 1.3.4 → 1.3.6

package/types/color/blend/index.d.ts

@@ -0,0 +1,129 @@
+import { RGBA } from './types';
+/**
+ * Blend two colors with the "normal" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function normal(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "multiply" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function multiply(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "screen" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function screen(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "overlay" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function overlay(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "darken" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function darken(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "lighten" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function lighten(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "color dodge" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function colorDodge(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "color burn" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function colorBurn(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "hard light" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function hardLight(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "soft light" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function softLight(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "difference" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function difference(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "exclusion" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function exclusion(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "hue" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function hue(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "saturation" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function saturation(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "color" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function color(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "luminosity" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @param source   The foreground color object { r,g,b,a } with the color channels being integers in the [0..255] range and the alpha channel being a fraction in [0..1]
+ * @return The blended color
+ */
+export declare function luminosity(backdrop: RGBA, source: RGBA): RGBA;

package/types/color/blend/non-separable-blend.d.ts

@@ -0,0 +1,9 @@
+import { NoAlphaBlender, RGBA } from './types';
+/**
+ * Blend two colors in a non-separable way
+ *
+ * @param backdrop The background color as an { r,g,b,a } object
+ * @param source   The foreground color as an { r,g,b,a } object
+ * @param callback The blend mode callback to apply
+ */
+export default function nonSeparableBlend(backdrop: RGBA, source: RGBA, callback: NoAlphaBlender): import('./types').RGB;

package/types/color/blend/non-separable-modes.d.ts

@@ -0,0 +1,33 @@
+import { RGB } from './types';
+/**
+ * Blend two colors with the "hue" blend mode
+ *
+ * @param backdrop The background color channel as an { r,g,b } object with each channel represented as a fraction
+ * @param source   The foreground color channel as an { r,g,b } object with each channel represented as a fraction
+ * @return The blended color
+ */
+export declare function hue(backdrop: RGB, source: RGB): RGB;
+/**
+ * Blend two colors with the "saturation" blend mode
+ *
+ * @param backdrop The background color channel as an { r,g,b } object with each channel represented as a fraction
+ * @param source   The foreground color channel as an { r,g,b } object with each channel represented as a fraction
+ * @return The blended color
+ */
+export declare function saturation(backdrop: RGB, source: RGB): RGB;
+/**
+ * Blend two colors with the "color" blend mode
+ *
+ * @param backdrop The background color channel as an { r,g,b } object with each channel represented as a fraction
+ * @param source   The foreground color channel as an { r,g,b } object with each channel represented as a fraction
+ * @return The blended color
+ */
+export declare function color(backdrop: RGB, source: RGB): RGB;
+/**
+ * Blend two colors with the "luminosity" blend mode
+ *
+ * @param backdrop The background color channel as an { r,g,b } object with each channel represented as a fraction
+ * @param source   The foreground color channel as an { r,g,b } object with each channel represented as a fraction
+ * @return The blended color
+ */
+export declare function luminosity(backdrop: RGB, source: RGB): RGB;

package/types/color/blend/separable-blend.d.ts

@@ -0,0 +1,9 @@
+import { ChannelBlender, RGB, RGBA } from './types';
+/**
+ * Blend two colors in a separable way (i.e. each color channel individually)
+ *
+ * @param backdrop The RGBA backdrop color
+ * @param source   The RGBA source color
+ * @param callback The blend mode callback to apply
+ */
+export default function separableBlend(backdrop: RGBA, source: RGBA, callback: ChannelBlender): RGB;

package/types/color/blend/separable-modes.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Algorithms for separable blend modes (i.e. where the same algorithms is applied to each color channel)
+ * @see https://www.w3.org/TR/compositing-1/#blendingseparable
+ */
+/**
+ * Blend two color channels with the "normal" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function normal(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "multiply" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function multiply(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "screen" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function screen(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "overlay" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function overlay(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "darken" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function darken(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "lighten" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function lighten(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "color dodge" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function colorDodge(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "color burn" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function colorBurn(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "hard light" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function hardLight(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "soft light" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function softLight(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "difference" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function difference(backdrop: number, source: number): number;
+/**
+ * Blend two color channels with the "exclusion" blend mode
+ *
+ * @param backdrop The background color channel as an integer from 0 to 255
+ * @param source   The foreground color channel as an integer from 0 to 255
+ * @return The blended channel value
+ */
+export declare function exclusion(backdrop: number, source: number): number;

package/types/color/blend/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * An object representing an RGB color
+ */
+export interface RGB {
+    /**
+     * Red channel as an integer from 0 to 255
+     */
+    r: number;
+    /**
+     * Green channel as an integer from 0 to 255
+     */
+    g: number;
+    /**
+     * Blue channel as an integer from 0 to 255
+     */
+    b: number;
+}
+/**
+ * An object representing an RGB color with an additional alpha channel
+ */
+export interface RGBA extends RGB {
+    /**
+     * Alpha channel as a fraction from 0 to 1
+     */
+    a: number;
+}
+/**
+ * Blends a single color channel of two colors
+ */
+export type ChannelBlender = (backdropChannel: number, sourceChannel: number) => number;
+/**
+ * Blends two RGBA colors into RGBA
+ */
+export type AlphaBlender = (backdrop: RGBA, source: RGBA) => RGBA;
+/**
+ * Blends two RGB(A) colors into RGB
+ */
+export type NoAlphaBlender = (backdrop: RGB, source: RGB) => RGB;

package/types/color/blend/unit.d.ts

@@ -0,0 +1,129 @@
+import { RGBA } from './types';
+/**
+ * Blend two colors with the "normal" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function normal(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "multiply" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function multiply(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "screen" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function screen(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "overlay" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function overlay(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "darken" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function darken(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "lighten" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function lighten(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "color dodge" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function colorDodge(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "color burn" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function colorBurn(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "hard light" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function hardLight(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "soft light" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function softLight(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "difference" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function difference(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "exclusion" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function exclusion(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "hue" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function hue(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "saturation" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function saturation(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "color" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function color(backdrop: RGBA, source: RGBA): RGBA;
+/**
+ * Blend two colors with the "luminosity" blend mode
+ *
+ * @param backdrop The background color object { r,g,b,a } with all channels in the [0..1] range
+ * @param source   The foreground color object { r,g,b,a } with all channels in the [0..1] range
+ * @return The blended color
+ */
+export declare function luminosity(backdrop: RGBA, source: RGBA): RGBA;

package/types/color/composite/composite-core.d.ts

@@ -0,0 +1,34 @@
+import { RGBAColor, CompositeOperation, CompositeContext } from './composite-types';
+export declare class CompositeCore implements CompositeContext {
+    applyComposite(source: RGBAColor, destination: RGBAColor, operation: CompositeOperation): RGBAColor;
+    private sourceOver;
+    private sourceIn;
+    private sourceOut;
+    private sourceAtop;
+    private destinationOver;
+    private destinationIn;
+    private destinationOut;
+    private destinationAtop;
+    private lighter;
+    private copy;
+    private xor;
+    private multiply;
+    private screen;
+    private overlay;
+    private darken;
+    private lighten;
+    private colorDodge;
+    private difference;
+    private hue;
+    private premultiply;
+    private unpremultiply;
+    private rgbToHsl;
+    private hslToRgb;
+    private saturation;
+    private color;
+    private luminosity;
+    private colorBurn;
+    private hardLight;
+    private softLight;
+    private exclusion;
+}

package/types/color/composite/composite-types.d.ts

@@ -0,0 +1,10 @@
+export type CompositeOperation = 'source-over' | 'source-in' | 'source-out' | 'source-atop' | 'destination-over' | 'destination-in' | 'destination-out' | 'destination-atop' | 'lighter' | 'copy' | 'xor' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';
+export interface RGBAColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface CompositeContext {
+    applyComposite(source: RGBAColor, destination: RGBAColor, operation: CompositeOperation): RGBAColor;
+}

package/types/color/composite/image-data-compositor.d.ts

@@ -0,0 +1,5 @@
+import { CompositeCore } from './composite-core';
+import { CompositeOperation } from './composite-types';
+export declare class ImageDataCompositor extends CompositeCore {
+    applyToImageData(sourceData: ImageData, destData: ImageData, operation: CompositeOperation, dx?: number, dy?: number): ImageData;
+}

package/types/color/composite/webgl-compositor.d.ts

@@ -0,0 +1,10 @@
+import { CompositeOperation } from './composite-types';
+export declare class WebGLCompositor {
+    private gl;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
+    createCompositeProgram(operation: CompositeOperation): WebGLProgram;
+    private createVertexShader;
+    private createFragmentShader;
+    private getBlendFunction;
+    private compileShader;
+}

package/types/color/composite/webgpu-compositor.d.ts

@@ -0,0 +1,10 @@
+import { CompositeOperation } from './composite-types';
+export declare class WebGPUCompositor {
+    private device;
+    private context;
+    constructor(device: GPUDevice, context: GPUCanvasContext);
+    createCompositePipeline(operation: CompositeOperation): Promise<GPURenderPipeline>;
+    private generateWGSLShader;
+    private getWGSLBlendFunction;
+    private getBlendState;
+}