canvas-editor-engine 2.0.21 → 2.1.2

package/dist/services/component.service.d.ts

@@ -1,5 +1,5 @@
 import { IWrapOptions } from "../types/general";
 export default class ComponentService {
-    protected static getTemplate(template: string, wrapOptions?: IWrapOptions): HTMLElement | null;
-    protected static getStyle(css: string): HTMLStyleElement | null;
+    protected getTemplate(template: string, wrapOptions?: IWrapOptions): HTMLElement | null;
+    protected getStyle(css: string): HTMLStyleElement | null;
 }

package/dist/services/crop.service.d.ts

@@ -1,7 +1,14 @@
+import ExcretionComponent from "../components/excretions.component";
+import AppConfig from "../config";
+import AppStoreRepository from "../store/storeRepository";
 import { IImageOptions } from "../types/image";
 export default class CropService {
-    static setup(): void;
-    static crop(ctx: CanvasRenderingContext2D): void;
-    static viewCropButton(): void;
-    static get options(): IImageOptions;
+    private appConfig;
+    private appStoreRepository;
+    private excretionComponent;
+    constructor(appConfig: AppConfig, appStoreRepository: AppStoreRepository, excretionComponent: ExcretionComponent);
+    setup(): void;
+    crop(ctx: CanvasRenderingContext2D): void;
+    viewCropButton(): void;
+    get options(): IImageOptions;
 }

package/dist/services/download.service.d.ts

@@ -1,4 +1,7 @@
+import CanvasComponent from "../components/canvas.component";
 export default class DownloadService {
-    static getDataUrl(): string;
-    static download(filename?: string): void;
+    private canvasComponent;
+    constructor(canvasComponent: CanvasComponent);
+    getDataUrl(): string;
+    download(filename?: string): void;
 }

package/dist/services/draw.service.d.ts

@@ -1,17 +1,25 @@
+import AppConfig from "../config";
+import AppStoreRepository from "../store/storeRepository";
 import type { IDrawImageArgs, IDrawImageProcessor, IFilterOptions, IImageLoggingDataVague, IImageOptions } from "../types/image";
 import { Project } from "../types/project";
+import EventService from "./event.service";
 export default class DrawService {
-    static imageProcessor: IDrawImageProcessor;
-    static drawImage(ctx: CanvasRenderingContext2D, src: string, options: IDrawImageArgs): void;
-    static drawProject(ctx: CanvasRenderingContext2D, project: Project): void;
-    static drawSmoothImage(useStore: boolean, options: IDrawImageArgs, filterOptions: IFilterOptions): void;
-    private static updateImageStateAfterVague;
-    private static getFilterArgs;
+    private appConfig;
+    private appStoreRepository;
+    private eventService;
+    imageProcessor: IDrawImageProcessor;
+    constructor(appConfig: AppConfig, appStoreRepository: AppStoreRepository, eventService: EventService);
+    drawImage(ctx: CanvasRenderingContext2D, src: string, options: IDrawImageArgs): void;
+    drawProject(ctx: CanvasRenderingContext2D, project: Project): void;
+    drawSmoothImage(useStore: boolean, options: IDrawImageArgs, filterOptions: IFilterOptions): void;
+    private updateImageStateAfterVague;
+    private getFilterArgs;
 }
 export declare class SCImage implements IDrawImageProcessor {
+    private appConfig;
     private img;
     private ctx;
-    constructor(src: string, ctx: CanvasRenderingContext2D);
+    constructor(appConfig: AppConfig, src: string, ctx: CanvasRenderingContext2D);
     draw(options?: IDrawImageArgs): Promise<unknown>;
     vague(options: IImageOptions, filterOptions: IFilterOptions): Promise<IImageLoggingDataVague>;
 }

package/dist/services/event.service.d.ts

@@ -9,8 +9,8 @@ export declare class EventAtom implements ControlEvent {
     action: (args?: any) => any;
 }
 export default class EventService {
-    static eventList: EventAtom[];
-    static subcribe(controlEvent: ControlEvent): void;
-    static dispatch(name: ControlEvent['name'], eventArgs?: any): void;
-    static applyEvents(baseElement: HTMLDivElement): void;
+    eventList: EventAtom[];
+    subcribe(controlEvent: ControlEvent): void;
+    dispatch(name: ControlEvent['name'], eventArgs?: any): void;
+    applyEvents(baseElement: HTMLDivElement): void;
 }

package/dist/services/logger.service.d.ts

@@ -1,20 +1,20 @@
 import { ILog, ILogItem } from "../types/log";
 import ComponentService from "./component.service";
 export default class LoggerService {
-    static log: ILog<ComponentService, any, any>;
-    static get components(): {
+    log: ILog<ComponentService, any, any>;
+    get components(): {
         add<TLogPrototype>(logItem: ILogItem<TLogPrototype>): void;
         get<TLogPrototype>(field: keyof ILog<ComponentService, any, any>, name: string): void;
     };
-    static get services(): {
+    get services(): {
         add<TLogPrototype>(logItem: ILogItem<TLogPrototype>): void;
         get<TLogPrototype>(field: keyof ILog<ComponentService, any, any>, name: string): void;
     };
-    static get planed(): {
+    get planed(): {
         add<TLogPrototype>(logItem: ILogItem<TLogPrototype>): void;
         get<TLogPrototype>(field: keyof ILog<ComponentService, any, any>, name: string): void;
     };
-    private static getMethods;
-    private static _add;
-    private static _get;
+    private getMethods;
+    private _add;
+    private _get;
 }

package/dist/services/projects.service.d.ts

@@ -1,11 +1,12 @@
 import { IProjectModule, TProjectModuleName } from "../types/project";
 import { ProjectFileSerializer } from "../utils/project-file-serializer";
 export default class ProjectsService {
-    private static _modules;
-    private static _serializer;
-    static on(moduleName: TProjectModuleName): {
+    private _modules;
+    private _serializer;
+    constructor();
+    on(moduleName: TProjectModuleName): {
         getSerializerInstance: (file: any) => ProjectFileSerializer;
         instance: IProjectModule;
     };
-    private static _addModule;
+    private _addModule;
 }

package/dist/services/pull-project.service.d.ts

@@ -1,8 +1,13 @@
+import AppStoreRepository from "../store/storeRepository";
 import { IUpdateProject, Project } from "../types/project";
+import ThroughHistoryService from "./through-history.service";
 export default class PullProjectService {
-    private static _project;
-    static get project(): Project;
-    static refreshProject(): void;
-    static updateProject(project: IUpdateProject): void;
-    static pull(name: Project['name'], description: Project['description']): void;
+    private throughHistoryService;
+    private appStoreRepository;
+    private _project;
+    constructor(throughHistoryService: ThroughHistoryService, appStoreRepository: AppStoreRepository);
+    get project(): Project;
+    refreshProject(): void;
+    updateProject(project: IUpdateProject): void;
+    pull(name: Project['name'], description: Project['description']): void;
 }

package/dist/services/through-history.service.d.ts

@@ -1,12 +1,17 @@
+import AppConfig from "../config";
+import AppStoreRepository from "../store/storeRepository";
 import { IHistoryLine } from "../types/history";
 import { Project } from "../types/project";
 export default class ThroughHistoryService {
-    static cache: IHistoryLine[];
-    static current(): IHistoryLine;
-    static prev(): IHistoryLine;
-    static undo(ctx: CanvasRenderingContext2D): void;
-    static redo(ctx: CanvasRenderingContext2D): void;
-    static clearCache(): void;
-    static recovery(project: Project): void;
-    private static updateCanvas;
+    private appConfig;
+    private appStoreRepository;
+    cache: IHistoryLine[];
+    constructor(appConfig: AppConfig, appStoreRepository: AppStoreRepository);
+    current(): IHistoryLine;
+    prev(): IHistoryLine;
+    undo(ctx: CanvasRenderingContext2D): void;
+    redo(ctx: CanvasRenderingContext2D): void;
+    clearCache(): void;
+    recovery(project: Project): void;
+    private updateCanvas;
 }

package/dist/services/tool-layers.service.d.ts

@@ -1,4 +1,7 @@
+import AppConfig from "../config";
 export default class ToolLayerService {
-    static multiplier: number;
-    static getLayerIndex(layerName: string): number;
+    private appConfig;
+    multiplier: number;
+    constructor(appConfig: AppConfig);
+    getLayerIndex(layerName: string): number;
 }

package/dist/services/tool.service.d.ts

@@ -1,10 +1,13 @@
+import CanvasComponent from "../components/canvas.component";
 import { ITool } from "../types/general";
 export default class ToolService {
-    static before: ITool | null;
-    static active: ITool | null;
-    static registry: ITool[];
-    static add(tool: ITool): boolean;
-    static setActive(id: ITool['id']): void;
-    static offActive(id?: ITool['id']): void;
-    private static off;
+    private canvasComponent;
+    before: ITool | null;
+    active: ITool | null;
+    registry: ITool[];
+    constructor(canvasComponent: CanvasComponent);
+    add(tool: ITool): boolean;
+    setActive(id: ITool['id']): void;
+    offActive(id?: ITool['id']): void;
+    private off;
 }

package/dist/store/history.state.d.ts

@@ -1,14 +1,16 @@
 import { StateService } from "../services/store.service";
+import ThroughHistoryService from "../services/through-history.service";
 import { IHistoryLine, TReducerNames } from "../types/history";
 export interface IHistoryState {
     historyLines: IHistoryLine[];
 }
 export declare class HistoryState implements StateService {
+    private throughHistoryService;
     private default;
     private _emergeCompleteIt;
     private _historyLines;
     get historyLines(): IHistoryState['historyLines'];
-    constructor();
+    constructor(throughHistoryService: ThroughHistoryService);
     reduce(name: TReducerNames, payload?: IHistoryLine | IHistoryState): void;
     emerge(completeIt: (history: IHistoryState['historyLines']) => void): void;
     reset(): void;

package/dist/store/image.state.d.ts

@@ -1,5 +1,6 @@
 import { StateService } from "../services/store.service";
 import { IPosition, ISize } from "../types/general";
+import AppStoreRepository from "./storeRepository";
 export interface IImageState {
     position: IPosition;
     size: ISize;
@@ -11,6 +12,7 @@ export interface IImageStateReduce {
     tempImageData?: IImageState['tempImageData'];
 }
 export declare class ImageState implements StateService {
+    private appStoreRepository;
     private default;
     private _position;
     private _size;
@@ -18,7 +20,7 @@ export declare class ImageState implements StateService {
     get position(): IImageState['position'];
     get size(): IImageState['size'];
     get tempImageData(): IImageState['tempImageData'];
-    constructor();
+    constructor(appStoreRepository: AppStoreRepository);
     reduce(payload: IImageStateReduce, title?: string): void;
     reset(): void;
     getEntry(): {

package/dist/store/store.d.ts

@@ -1,6 +1,8 @@
 import { StoreService } from "../services/store.service";
+import ThroughHistoryService from "../services/through-history.service";
 import { HistoryState } from "./history.state";
 import { ImageState } from "./image.state";
+import AppStoreRepository from "./storeRepository";
 export declare class Store implements StoreService {
     imageState: ImageState;
     historyState: HistoryState;
@@ -8,6 +10,8 @@ export declare class Store implements StoreService {
     reset(): void;
 }
 export default class AppStore {
-    static store: Store;
-    static subscribe(to: 'history', completeIt: (...args: any) => void): void;
+    private throughHistoryService;
+    private appStoreRepository;
+    constructor(throughHistoryService: ThroughHistoryService, appStoreRepository: AppStoreRepository);
+    subscribe(to: 'history', completeIt: (...args: any) => void): void;
 }

package/dist/store/storeRepository.d.ts

@@ -0,0 +1,4 @@
+import { Store } from "./store";
+export default class AppStoreRepository {
+    store: Store;
+}

package/dist/utils/filter.d.ts

@@ -1,9 +1,11 @@
+import AppConfig from "../config";
 import { IExtendedImageDataModel, type IImageOptions, type IImageSize, type TBuff, type TRGBABuff } from "../types/image";
 import type { ISize, THEXColor } from '../types/general';
 export declare class Filter {
+    private appConfig;
     ctx: CanvasRenderingContext2D;
     imageSize: IImageSize;
-    constructor(ctx: CanvasRenderingContext2D);
+    constructor(appConfig: AppConfig, ctx: CanvasRenderingContext2D);
     setImageSize(size: IImageSize): void;
     copy(options: IImageOptions): ImageData;
     copyExtendedModel(options: IImageOptions): IExtendedImageDataModel;

package/dist/web-component.d.ts

@@ -1,4 +1,6 @@
+import CanvasComponent from "./components/canvas.component";
 import { TComponent } from "./types/general";
+import AppConfig from "./config";
 export declare class WebComponentWrapper {
     baseElement: HTMLDivElement;
     editorWrapElement: HTMLDivElement;
@@ -22,5 +24,12 @@ export declare class WebComponentWrapper {
     private _baseStyle;
 }
 export default class WebComponent extends HTMLElement {
+    appConfig: AppConfig;
+    canvasComponent: CanvasComponent;
+    canvasElement: HTMLDivElement;
     constructor();
+    get initial(): {
+        editorElement: HTMLDivElement;
+        canvasSelector: string;
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canvas-editor-engine",
-  "version": "2.0.21",
+  "version": "2.1.2",
   "description": "CanvasEditorEngine library, use: [typescript] [canvas]",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",