@ng-web-apis/canvas/index.d.ts

A library for declarative use of Canvas API with Angular

import * as i0 from '@angular/core';
import { PipeTransform, OnDestroy, InjectionToken, Type, ExistingProvider } from '@angular/core';
import * as _ng_web_apis_canvas from '@ng-web-apis/canvas';

declare class WaCanvas2d {
    private readonly context;
    private readonly method;
    waOpaque: "";
    waDesynchronized: "";
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvas2d, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvas2d, "canvas[waCanvas2d]", never, { "waOpaque": { "alias": "waOpaque"; "required": false; }; "waDesynchronized": { "alias": "waDesynchronized"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasClipPath {
    readonly pathSteps: i0.Signal<readonly _ng_web_apis_canvas.CanvasMethod[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasClipPath, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WaCanvasClipPath, "canvas-clip-path", never, {}, {}, ["pathSteps"], ["*"], true, never>;
}

declare class WaCanvasDrawImage {
    private readonly method;
    image?: CanvasImageSource;
    dX: number;
    dY: number;
    dWidth?: number;
    dHeight?: number;
    sX?: number;
    sY?: number;
    sWidth?: number;
    sHeight?: number;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasDrawImage, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasDrawImage, "canvas-draw-image", never, { "image": { "alias": "image"; "required": false; }; "dX": { "alias": "dX"; "required": false; }; "dY": { "alias": "dY"; "required": false; }; "dWidth": { "alias": "dWidth"; "required": false; }; "dHeight": { "alias": "dHeight"; "required": false; }; "sX": { "alias": "sX"; "required": false; }; "sY": { "alias": "sY"; "required": false; }; "sWidth": { "alias": "sWidth"; "required": false; }; "sHeight": { "alias": "sHeight"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasPath {
    private readonly pathSteps;
    private readonly method;
    closed: boolean;
    fillRule?: CanvasFillRule;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasPath, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasPath, "canvas-path:not([path])", never, { "closed": { "alias": "closed"; "required": false; }; "fillRule": { "alias": "fillRule"; "required": false; }; }, {}, ["pathSteps"], never, true, never>;
}

declare class WaCanvasPath2d {
    private readonly method;
    path: Path2D;
    fillRule?: CanvasFillRule;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasPath2d, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasPath2d, "canvas-path[path]", never, { "path": { "alias": "path"; "required": false; }; "fillRule": { "alias": "fillRule"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasText {
    private readonly method;
    text: string;
    x: number;
    y: number;
    maxWidth?: number;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasText, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasText, "canvas-text", never, { "text": { "alias": "text"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; }, {}, never, never, true, never>;
}

type Context2dProcessor = (context: CanvasRenderingContext2D) => void;

interface CanvasMethod {
    call: Context2dProcessor;
}

declare class WaCanvasArc implements CanvasMethod {
    x: number;
    y: number;
    radius: number;
    startAngle: number;
    endAngle: number;
    anticlockwise: boolean;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasArc, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasArc, "canvas-arc", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "startAngle": { "alias": "startAngle"; "required": false; }; "endAngle": { "alias": "endAngle"; "required": false; }; "anticlockwise": { "alias": "anticlockwise"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasArcTo implements CanvasMethod {
    x1: number;
    y1: number;
    x2: number;
    y2: number;
    radius: number;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasArcTo, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasArcTo, "canvas-arc-to", never, { "x1": { "alias": "x1"; "required": false; }; "y1": { "alias": "y1"; "required": false; }; "x2": { "alias": "x2"; "required": false; }; "y2": { "alias": "y2"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasBezierCurveTo implements CanvasMethod {
    cp1x: number;
    cp1y: number;
    cp2x: number;
    cp2y: number;
    x: number;
    y: number;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasBezierCurveTo, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasBezierCurveTo, "canvas-bezier-curve-to", never, { "cp1x": { "alias": "cp1x"; "required": false; }; "cp1y": { "alias": "cp1y"; "required": false; }; "cp2x": { "alias": "cp2x"; "required": false; }; "cp2y": { "alias": "cp2y"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasEllipse implements CanvasMethod {
    x: number;
    y: number;
    radiusX: number;
    radiusY: number;
    rotation: number;
    startAngle: number;
    endAngle: number;
    anticlockwise: boolean;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasEllipse, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasEllipse, "canvas-ellipse", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "radiusX": { "alias": "radiusX"; "required": false; }; "radiusY": { "alias": "radiusY"; "required": false; }; "startAngle": { "alias": "startAngle"; "required": false; }; "endAngle": { "alias": "endAngle"; "required": false; }; "anticlockwise": { "alias": "anticlockwise"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasLineTo implements CanvasMethod {
    x: number;
    y: number;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasLineTo, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasLineTo, "canvas-line-to", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasMoveTo implements CanvasMethod {
    x: number;
    y: number;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasMoveTo, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasMoveTo, "canvas-move-to", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasQuadraticCurveTo implements CanvasMethod {
    cpx: number;
    cpy: number;
    x: number;
    y: number;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasQuadraticCurveTo, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasQuadraticCurveTo, "canvas-quadratic-curve-to", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "cpx": { "alias": "cpx"; "required": false; }; "cpy": { "alias": "cpy"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasRect implements CanvasMethod {
    x: number;
    y: number;
    width: number;
    height: number;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasRect, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasRect, "canvas-rect", never, { "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasGradientPipe implements PipeTransform {
    private readonly context;
    transform(stops: Map<number, string>, x0: number, y0: number, x1: number, y1: number): CanvasGradient;
    transform(stops: Map<number, string>, x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasGradientPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WaCanvasGradientPipe, "gradient", true>;
}

declare class WaCanvasPathPipe implements PipeTransform {
    transform(path: string): Path2D;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasPathPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WaCanvasPathPipe, "path", true>;
}

declare class WaCanvasPatternPipe implements PipeTransform {
    private readonly context;
    transform(image: CanvasImageSource, repetition?: string): CanvasPattern;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasPatternPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WaCanvasPatternPipe, "pattern", true>;
}

declare class WaCanvasRadPipe implements PipeTransform {
    transform(input: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasRadPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WaCanvasRadPipe, "rad", true>;
}

declare class WaCanvasTransformPipe implements PipeTransform {
    private readonly isBrowser;
    transform(value: string): DOMMatrix | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasTransformPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<WaCanvasTransformPipe, "transform", true>;
}

declare class WaCanvasClip implements CanvasMethod {
    clip: Path2D | WaCanvasClipPath;
    clipFillRule?: CanvasFillRule;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasClip, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasClip, "canvas-draw-image[clip],canvas-draw-image[clipFillRule],canvas-path[clip],canvas-path[clipFillRule],canvas-text[clip],canvas-text[clipFillRule]", never, { "clip": { "alias": "clip"; "required": false; }; "clipFillRule": { "alias": "clipFillRule"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasCompositing implements CanvasMethod, CanvasCompositing {
    globalAlpha: number;
    globalCompositeOperation: GlobalCompositeOperation;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasCompositing, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasCompositing, "canvas-draw-image[globalAlpha],canvas-draw-image[globalCompositeOperation],canvas-path[globalAlpha],canvas-path[globalCompositeOperation],canvas-text[globalAlpha],canvas-text[globalCompositeOperation]", never, { "globalAlpha": { "alias": "globalAlpha"; "required": false; }; "globalCompositeOperation": { "alias": "globalCompositeOperation"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasFillStrokeStyles implements CanvasMethod {
    fillStyle: CanvasGradient | CanvasPattern | string;
    strokeStyle: CanvasGradient | CanvasPattern | string;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasFillStrokeStyles, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasFillStrokeStyles, "canvas-path[fillStyle],canvas-path[strokeStyle],canvas-text[fillStyle],canvas-text[strokeStyle]", never, { "fillStyle": { "alias": "fillStyle"; "required": false; }; "strokeStyle": { "alias": "strokeStyle"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasFilter implements CanvasMethod, CanvasFilters {
    filter: string;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasFilter, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasFilter, "canvas-draw-image[filter],canvas-path[filter],canvas-text[filter]", never, { "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasImageSmoothing implements CanvasMethod, CanvasImageSmoothing {
    imageSmoothingEnabled: boolean;
    imageSmoothingQuality: ImageSmoothingQuality;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasImageSmoothing, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasImageSmoothing, "canvas-draw-image[imageSmoothingEnabled],canvas-draw-image[imageSmoothingQuality],canvas-path[imageSmoothingEnabled],canvas-path[imageSmoothingQuality],canvas-text[imageSmoothingEnabled],canvas-text[imageSmoothingQuality]", never, { "imageSmoothingEnabled": { "alias": "imageSmoothingEnabled"; "required": false; }; "imageSmoothingQuality": { "alias": "imageSmoothingQuality"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasPathDrawingStyles implements CanvasMethod, Omit<CanvasPathDrawingStyles, 'getLineDash' | 'setLineDash'> {
    lineCap: CanvasLineCap;
    lineDashOffset: number;
    lineJoin: CanvasLineJoin;
    lineWidth: number;
    lineDash: number[];
    miterLimit: number;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasPathDrawingStyles, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasPathDrawingStyles, "canvas-path[lineCap],canvas-path[lineDashOffset],canvas-path[lineJoin],canvas-path[lineWidth],canvas-path[lineDash],canvas-path[miterLimit],canvas-text[lineCap],canvas-text[lineDashOffset],canvas-text[lineJoin],canvas-text[lineWidth],canvas-text[lineDash],canvas-text[miterLimit]", never, { "lineCap": { "alias": "lineCap"; "required": false; }; "lineDashOffset": { "alias": "lineDashOffset"; "required": false; }; "lineJoin": { "alias": "lineJoin"; "required": false; }; "lineWidth": { "alias": "lineWidth"; "required": false; }; "lineDash": { "alias": "lineDash"; "required": false; }; "miterLimit": { "alias": "miterLimit"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasShadowStyles implements CanvasShadowStyles {
    shadowBlur: number;
    shadowColor: string;
    shadowOffsetX: number;
    shadowOffsetY: number;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasShadowStyles, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasShadowStyles, "canvas-draw-image[shadowBlur],canvas-draw-image[shadowColor],canvas-draw-image[shadowOffsetX],canvas-draw-image[shadowOffsetY],canvas-path[shadowBlur],canvas-path[shadowColor],canvas-path[shadowOffsetX],canvas-path[shadowOffsetY],canvas-text[shadowBlur],canvas-text[shadowColor],canvas-text[shadowOffsetX],canvas-text[shadowOffsetY]", never, { "shadowBlur": { "alias": "shadowBlur"; "required": false; }; "shadowColor": { "alias": "shadowColor"; "required": false; }; "shadowOffsetX": { "alias": "shadowOffsetX"; "required": false; }; "shadowOffsetY": { "alias": "shadowOffsetY"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasTextDrawingStyles implements CanvasMethod, CanvasTextDrawingStyles {
    direction: CanvasDirection;
    font: string;
    textAlign: CanvasTextAlign;
    fontKerning: CanvasFontKerning;
    textBaseline: CanvasTextBaseline;
    fontStretch: CanvasFontStretch;
    fontVariantCaps: CanvasFontVariantCaps;
    letterSpacing: string;
    textRendering: CanvasTextRendering;
    wordSpacing: string;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasTextDrawingStyles, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasTextDrawingStyles, "canvas-text[direction],canvas-text[font],canvas-text[textAlign],canvas-text[textBaseline]", never, { "direction": { "alias": "direction"; "required": false; }; "font": { "alias": "font"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; "fontKerning": { "alias": "fontKerning"; "required": false; }; "textBaseline": { "alias": "textBaseline"; "required": false; }; }, {}, never, never, true, never>;
}

declare class WaCanvasTransform implements CanvasMethod {
    private readonly parent;
    transform: DOMMatrix | null;
    call(context: CanvasRenderingContext2D): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaCanvasTransform, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WaCanvasTransform, "canvas[transform],canvas-draw-image[transform],canvas-path[transform],canvas-text[transform]", never, { "transform": { "alias": "transform"; "required": false; }; }, {}, never, never, true, never>;
}

declare const WaCanvas: readonly [typeof WaCanvas2d, typeof WaCanvasClipPath, typeof WaCanvasDrawImage, typeof WaCanvasPath, typeof WaCanvasPath2d, typeof WaCanvasText, typeof WaCanvasArc, typeof WaCanvasArcTo, typeof WaCanvasBezierCurveTo, typeof WaCanvasEllipse, typeof WaCanvasLineTo, typeof WaCanvasMoveTo, typeof WaCanvasQuadraticCurveTo, typeof WaCanvasRect, typeof WaCanvasClip, typeof WaCanvasCompositing, typeof WaCanvasFillStrokeStyles, typeof WaCanvasFilter, typeof WaCanvasImageSmoothing, typeof WaCanvasPathDrawingStyles, typeof WaCanvasShadowStyles, typeof WaCanvasTextDrawingStyles, typeof WaCanvasGradientPipe, typeof WaCanvasPathPipe, typeof WaCanvasPatternPipe, typeof WaCanvasRadPipe, typeof WaCanvasTransform, typeof WaCanvasTransformPipe];

declare class WaDrawService implements OnDestroy, CanvasMethod {
    private readonly subscription;
    constructor();
    call: Context2dProcessor;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WaDrawService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WaDrawService>;
}

declare const WA_CANVAS_2D_CONTEXT: InjectionToken<CanvasRenderingContext2D>;

declare const WA_CANVAS_METHOD: InjectionToken<CanvasMethod>;
declare function asCanvasMethod(useExisting: Type<CanvasMethod>): ExistingProvider;

declare const WA_CANVAS_PROPERTIES: InjectionToken<CanvasMethod[]>;
declare function asCanvasProperty(useExisting: Type<CanvasMethod>): ExistingProvider;

export { WA_CANVAS_2D_CONTEXT, WA_CANVAS_METHOD, WA_CANVAS_PROPERTIES, WaCanvas, WaCanvas2d, WaCanvasArc, WaCanvasArcTo, WaCanvasBezierCurveTo, WaCanvasClip, WaCanvasClipPath, WaCanvasCompositing, WaCanvasDrawImage, WaCanvasEllipse, WaCanvasFillStrokeStyles, WaCanvasFilter, WaCanvasGradientPipe, WaCanvasImageSmoothing, WaCanvasLineTo, WaCanvasMoveTo, WaCanvasPath, WaCanvasPath2d, WaCanvasPathDrawingStyles, WaCanvasPathPipe, WaCanvasPatternPipe, WaCanvasQuadraticCurveTo, WaCanvasRadPipe, WaCanvasRect, WaCanvasShadowStyles, WaCanvasText, WaCanvasTextDrawingStyles, WaCanvasTransform, WaCanvasTransformPipe, WaDrawService, asCanvasMethod, asCanvasProperty };
export type { CanvasMethod, Context2dProcessor };