canvas-editor-engine 2.0.20 → 2.1.1

package/dist/components/canvas.component.d.ts

@@ -1,21 +1,28 @@
+import AppConfig from "../config";
 import { TSubscribeAction, TSubscriptionTypes } from "../types/canvas";
 import { ICursorPosition, TCursorStyleName } from "../types/cursor";
 import ComponentService from "../services/component.service";
+import LoggerService from "../services/logger.service";
+import ToolLayerService from "../services/tool-layers.service";
 export default class CanvasComponent extends ComponentService {
-    private static template;
-    private static css;
-    static eventListener: HTMLDivElement;
-    static canvas: HTMLCanvasElement;
-    static ctx: CanvasRenderingContext2D | null;
-    private static subscriptions;
-    private static _cursorStyle;
-    static getComponent(): {
+    private appConfig;
+    private loggerService;
+    private toolLayerService;
+    constructor(appConfig: AppConfig, loggerService: LoggerService, toolLayerService: ToolLayerService);
+    private template;
+    private css;
+    eventListener: HTMLDivElement;
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D | null;
+    private subscriptions;
+    private _cursorStyle;
+    getComponent(): {
         canvasTemplate: HTMLElement;
         canvasStyle: HTMLStyleElement;
     };
-    static getCanvasSelector(): string;
-    static set cursorStyle(styleName: TCursorStyleName | undefined | null);
-    static getCursorPosition(event: MouseEvent): ICursorPosition;
-    static subscribe(eventName: TSubscriptionTypes, action: TSubscribeAction): void;
-    static simulateSubscriptions(): void;
+    getCanvasSelector(): string;
+    set cursorStyle(styleName: TCursorStyleName | undefined | null);
+    getCursorPosition(event: MouseEvent): ICursorPosition;
+    subscribe(eventName: TSubscriptionTypes, action: TSubscribeAction): void;
+    simulateSubscriptions(): void;
 }

package/dist/components/excretions.component.d.ts

@@ -1,32 +1,41 @@
 import ComponentService from "../services/component.service";
+import ToolService from "../services/tool.service";
+import CanvasComponent from "./canvas.component";
 import type { IExcretionsCoords, TExcretionStyle, TExcretionToolState } from "../types/excretion";
+import LoggerService from "../services/logger.service";
+import ToolLayerService from "../services/tool-layers.service";
 export default class ExcretionsComponent extends ComponentService {
-    private static template;
-    private static templateExcretion;
-    private static _excretionDefaultStyle;
-    private static css;
-    static excretionWrap: HTMLElement;
-    private static _excretions;
-    private static _excretionState;
-    private static _excretionActivity;
-    private static _excretionToolState;
-    private static _tempCoords;
-    static excretionsCoords: IExcretionsCoords[];
-    private static _additionStyle;
-    static get additionStyle(): TExcretionStyle;
-    static set additionStyle(value: TExcretionStyle);
-    private static applyExcretionStyle;
-    private static determineCropStyle;
-    private static determineDefaultStyle;
-    private static tool;
-    static getComponent(): {
+    private toolService;
+    private loggerService;
+    private toolLayerService;
+    private canvasComponent;
+    constructor(toolService: ToolService, loggerService: LoggerService, toolLayerService: ToolLayerService, canvasComponent: CanvasComponent);
+    private template;
+    private templateExcretion;
+    private _excretionDefaultStyle;
+    private css;
+    excretionWrap: HTMLElement;
+    private _excretions;
+    private _excretionState;
+    private _excretionActivity;
+    private _excretionToolState;
+    private _tempCoords;
+    excretionsCoords: IExcretionsCoords[];
+    private _additionStyle;
+    get additionStyle(): TExcretionStyle;
+    set additionStyle(value: TExcretionStyle);
+    private applyExcretionStyle;
+    private determineCropStyle;
+    private determineDefaultStyle;
+    private tool;
+    getComponent(): {
         excretionsTemplate: HTMLElement;
         excretionsStyle: HTMLStyleElement;
     };
-    private static set excretionState(value);
-    static setToolState(toolState: TExcretionToolState): void;
-    static clearExcretionsCoords(): void;
-    private static getTempCoords;
-    private static endExcretion;
-    private static emmit;
+    private set excretionState(value);
+    setToolState(toolState: TExcretionToolState): void;
+    clearExcretionsCoords(): void;
+    private getTempCoords;
+    private endExcretion;
+    private emmit;
 }

package/dist/components/loading.component.d.ts

@@ -1,14 +1,19 @@
 import ComponentService from "../services/component.service";
+import EventService from "../services/event.service";
+import LoggerService from "../services/logger.service";
 export default class LoadingComponent extends ComponentService {
-    private static template;
-    private static css;
-    static loading: HTMLElement;
-    static getComponent(): {
+    private loggerService;
+    private eventService;
+    constructor(loggerService: LoggerService, eventService: EventService);
+    private template;
+    private css;
+    loading: HTMLElement;
+    getComponent(): {
         loadingTemplate: HTMLElement;
         loadingStyle: HTMLStyleElement;
     };
-    static hide(): void;
-    static view(): void;
-    private static subscribeLoadingStart;
-    private static subscribeLoadingEnd;
+    hide(): void;
+    view(): void;
+    private subscribeLoadingStart;
+    private subscribeLoadingEnd;
 }

package/dist/components/pipette.component.d.ts

@@ -1,23 +1,30 @@
 import { TPipetteState } from "../types/pipette";
 import { THEXColor } from "../types/general";
+import CanvasComponent from "./canvas.component";
 import ComponentService from "../services/component.service";
+import ToolService from "../services/tool.service";
+import LoggerService from "../services/logger.service";
 export default class PipetteComponent extends ComponentService {
-    static template: string;
-    static css: string;
-    static pipette: HTMLElement;
-    private static _pipetteColor;
-    static set pipetteColor(color: THEXColor);
-    static get pipetteColor(): THEXColor;
-    private static _pipetteColorElement;
-    private static _pipetteState;
-    private static tool;
-    static getComponent(): {
+    private toolService;
+    private loggerService;
+    private canvasComponent;
+    constructor(toolService: ToolService, loggerService: LoggerService, canvasComponent: CanvasComponent);
+    template: string;
+    css: string;
+    pipette: HTMLElement;
+    private _pipetteColor;
+    set pipetteColor(color: THEXColor);
+    get pipetteColor(): THEXColor;
+    private _pipetteColorElement;
+    private _pipetteState;
+    private tool;
+    getComponent(): {
         pipetteTemplate: HTMLElement;
         pipetteStyle: HTMLStyleElement;
     };
-    static setState(state: TPipetteState): void;
-    static emmit(): void;
-    private static setColorFromChoosenPixel;
-    private static show;
-    private static hide;
+    setState(state: TPipetteState): void;
+    emmit(): void;
+    private setColorFromChoosenPixel;
+    private show;
+    private hide;
 }

package/dist/components/slot.component.d.ts

@@ -1,9 +1,12 @@
 import ComponentService from "../services/component.service";
+import LoggerService from "../services/logger.service";
 export default class SlotComponent extends ComponentService {
-    private static template;
-    private static css;
-    static slot: HTMLSlotElement;
-    static getComponent(slotName: string): {
+    private loggerService;
+    constructor(loggerService: LoggerService);
+    private template;
+    private css;
+    slot: HTMLSlotElement;
+    getComponent(slotName: string): {
         slotTemplate: HTMLElement;
         slotStyle: HTMLStyleElement;
     };

package/dist/config.d.ts

@@ -3,21 +3,17 @@ export interface ILayer {
     name: string;
     index: number;
 }
-export declare abstract class ConfigStore {
-    static _WEB_COMPONENT_TAG_NAME: string;
-    static _CANVAS_SIZE: ICanvasSize;
-    static _LAYERS: ILayer[];
-}
-export declare class ConfigFabric implements ConfigStore {
-    protected static _WEB_COMPONENT_TAG_NAME: string;
-    protected static _CANVAS_SIZE: ICanvasSize;
-    protected static _LAYERS: ILayer[];
+export declare class ConfigFabric {
+    protected _WEB_COMPONENT_TAG_NAME: string;
+    protected _CANVAS_SIZE: ICanvasSize;
+    protected _LAYERS: ILayer[];
 }
 export default class AppConfig extends ConfigFabric {
-    static get WEB_COMPONENT_TAG_NAME(): string;
-    static set WEB_COMPONENT_TAG_NAME(value: string | undefined);
-    static get CANVAS_SIZE(): ICanvasSize;
-    static set CANVAS_SIZE(value: ICanvasSize | undefined);
-    static get LAYERS(): ILayer[];
-    static set LAYERS(value: ILayer[]);
+    constructor();
+    get WEB_COMPONENT_TAG_NAME(): string;
+    set WEB_COMPONENT_TAG_NAME(value: string | undefined);
+    get CANVAS_SIZE(): ICanvasSize;
+    set CANVAS_SIZE(value: ICanvasSize | undefined);
+    get LAYERS(): ILayer[];
+    set LAYERS(value: ILayer[]);
 }

package/dist/filters/collection/vague.d.ts

@@ -1,9 +1,10 @@
 import type { IFilterOptions, IImageLoggingDataVague, IImageOptions, TFilterMethod } from "../../types/image";
 import { Filter } from "../../utils/filter";
+import AppConfig from "../../config";
 export default class VagueFilter extends Filter {
     options: IImageOptions;
     filterList: TFilterMethod[];
-    constructor(ctx: CanvasRenderingContext2D, options: IImageOptions);
+    constructor(appConfig: AppConfig, ctx: CanvasRenderingContext2D, options: IImageOptions);
     on(action: TFilterMethod, filterOptions: IFilterOptions): Promise<IImageLoggingDataVague>;
     pixel(imageData: ImageData, filterOptions: IFilterOptions): ImageData;
     private getQualityProcessedRemainder;

package/dist/index.d.ts

@@ -17,19 +17,18 @@ import ProjectsService from "./services/projects.service";
 import PullProjectService from "./services/pull-project.service";
 import AppStore from "./store/store";
 declare class CanvasEditorEngine {
-    constructor(webComponentTagName?: string);
+    private appConfig;
+    constructor(appConfig: AppConfig);
     getInitial(): {
         tag: string;
         component: typeof WebComponent;
     };
 }
 declare class StaticCanvasEditorEngine extends CanvasEditorEngine {
-    constructor(webComponentTagName?: string);
+    constructor(appConfig: AppConfig);
     init(): void;
 }
 declare class VueCanvasEditorEngine extends CanvasEditorEngine {
-    constructor(webComponentTagName?: string);
-    getContext2D(): CanvasRenderingContext2D;
-    getCanvas(): HTMLCanvasElement;
+    constructor(appConfig: AppConfig);
 }
 export { AppConfig, PipetteComponent, CanvasComponent, ExcretionComponent, SlotComponent, LoadingComponent, ToolService, DrawService, LoggerService, CropService, DownloadService, ToolLayerService, EventService, ThroughHistoryService, ProjectsService, PullProjectService, StaticCanvasEditorEngine, VueCanvasEditorEngine, AppStore, };