canvas-editor-engine 2.0.12 → 2.0.13

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,7 @@
+import { IImageOptions } from "../types/image";
+export default class CropService {
+    static setup(): void;
+    static crop(ctx: CanvasRenderingContext2D): void;
+    static viewCropButton(): void;
+    static get options(): IImageOptions;
+}

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

@@ -0,0 +1,4 @@
+export default class DownloadService {
+    static getDataUrl(): string;
+    static download(filename?: string): void;
+}

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

@@ -0,0 +1,17 @@
+import type { IDrawImageArgs, IDrawImageProcessor, IFilterOptions, IImageLoggingDataVague, IImageOptions } from "../types/image";
+import { Project } from "../types/project";
+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;
+}
+export declare class SCImage implements IDrawImageProcessor {
+    private img;
+    private ctx;
+    constructor(src: string, ctx: CanvasRenderingContext2D);
+    draw(options?: IDrawImageArgs): Promise<unknown>;
+    vague(options: IImageOptions, filterOptions: IFilterOptions): Promise<IImageLoggingDataVague>;
+}

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

@@ -0,0 +1,16 @@
+import { IGUID4 } from "../types/general";
+export declare abstract class ControlEvent {
+    name: string;
+    action: (args?: any) => any;
+}
+export declare class EventAtom implements ControlEvent {
+    id: IGUID4;
+    name: string;
+    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;
+}

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

@@ -0,0 +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(): {
+        add<TLogPrototype>(logItem: ILogItem<TLogPrototype>): void;
+        get<TLogPrototype>(field: keyof ILog<ComponentService, any, any>, name: string): void;
+    };
+    static get services(): {
+        add<TLogPrototype>(logItem: ILogItem<TLogPrototype>): void;
+        get<TLogPrototype>(field: keyof ILog<ComponentService, any, any>, name: string): void;
+    };
+    static 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;
+}

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

@@ -0,0 +1,11 @@
+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): {
+        getSerializerInstance: (file: any) => ProjectFileSerializer;
+        instance: IProjectModule;
+    };
+    private static _addModule;
+}

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

@@ -0,0 +1,8 @@
+import { IUpdateProject, Project } from "../types/project";
+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;
+}

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

@@ -0,0 +1,6 @@
+export declare abstract class StateService {
+    abstract reset(): void;
+}
+export declare abstract class StoreService {
+    abstract reset(): void;
+}

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

@@ -0,0 +1,12 @@
+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;
+}

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

@@ -0,0 +1,4 @@
+export default class ToolLayerService {
+    static multiplier: number;
+    static getLayerIndex(layerName: string): number;
+}

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

@@ -0,0 +1,10 @@
+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;
+}

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

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

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

@@ -0,0 +1,30 @@
+import { StateService } from "../services/store.service";
+import { IPosition, ISize } from "../types/general";
+export interface IImageState {
+    position: IPosition;
+    size: ISize;
+    tempImageData: ImageData | null;
+}
+export interface IImageStateReduce {
+    position?: IImageState['position'];
+    size?: IImageState['size'];
+    tempImageData?: IImageState['tempImageData'];
+}
+export declare class ImageState implements StateService {
+    private default;
+    private _position;
+    private _size;
+    private _tempImageData;
+    get position(): IImageState['position'];
+    get size(): IImageState['size'];
+    get tempImageData(): IImageState['tempImageData'];
+    constructor();
+    reduce(payload: IImageStateReduce, title?: string): void;
+    reset(): void;
+    getEntry(): {
+        position: IPosition;
+        size: ISize;
+        imageData: ImageData;
+    };
+    addToHistory(title: string): void;
+}

package/dist/store/store.d.ts

@@ -0,0 +1,13 @@
+import { StoreService } from "../services/store.service";
+import { HistoryState } from "./history.state";
+import { ImageState } from "./image.state";
+export declare class Store implements StoreService {
+    imageState: ImageState;
+    historyState: HistoryState;
+    constructor(imageState: ImageState, historyState: HistoryState);
+    reset(): void;
+}
+export default class AppStore {
+    static store: Store;
+    static subscribe(to: 'history', completeIt: (...args: any) => void): void;
+}

package/dist/types/canvas.d.ts

@@ -0,0 +1,10 @@
+import { ICursorPosition } from "./cursor";
+export interface ICanvasSize {
+    width: number;
+    height: number;
+}
+export type TSubscriptionTypes = 'click' | 'mousemove' | 'mousedown' | 'mouseup';
+export type TSubscribeAction = (event: MouseEvent, cursorPosition?: ICursorPosition) => void;
+export type TSubscriptions = {
+    [key in TSubscriptionTypes]: TSubscribeAction[];
+};

package/dist/types/cursor.d.ts

@@ -0,0 +1,9 @@
+export interface ICursorPosition {
+    x: number;
+    y: number;
+}
+export interface ICursorStyle {
+    before: TCursorStyleName | null;
+    current: TCursorStyleName | null;
+}
+export type TCursorStyleName = 'default' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'copy' | 'alias' | 'move' | 'not-allowed' | 'grab' | 'grabbing' | 'zoom-in' | 'zoom-out';

package/dist/types/excretion.d.ts

@@ -0,0 +1,27 @@
+export interface IExcretionsCoords {
+    start?: {
+        x: number;
+        y: number;
+    };
+    end?: {
+        x: number;
+        y: number;
+    };
+}
+export interface IExcretionTempStart {
+    start: {
+        x: number;
+        y: number;
+    };
+}
+export interface IExcretionTempEnd {
+    end: {
+        x: number;
+        y: number;
+    };
+}
+export type TExcretionTempCoords = (IExcretionTempStart | IExcretionTempEnd)[];
+export type TExcretionToolState = 'taken' | 'abandoned';
+export type TExcretionState = 'create' | 'add' | 'remove' | 'abandoned';
+export type TExcretionActivity = 'active' | 'end' | 'abandoned';
+export type TExcretionStyle = 'default' | 'crop';

package/dist/types/general.d.ts

@@ -0,0 +1,24 @@
+export type THEXColor = `#${string}`;
+export type TComponent = HTMLElement | HTMLDivElement | HTMLCanvasElement;
+export interface IWrapOptions {
+    tag?: string;
+    className?: string;
+    id?: string;
+}
+export interface ITool {
+    id: number;
+    name: string;
+    onAction?: (...args: any) => void;
+    offAction?: (...args: any) => void;
+    support?: (...args: any) => void;
+}
+export type IGUID4 = `${number}-${number}-${number}-${number}`;
+export interface IPosition {
+    x: number;
+    y: number;
+}
+export interface ISize {
+    width: number;
+    height: number;
+}
+export type TStringMatrix = string[][];

package/dist/types/history.d.ts

@@ -0,0 +1,7 @@
+import { IImageState } from "../store/image.state";
+export interface IHistoryLine {
+    stateName: string;
+    stateValue: IImageState;
+    view: string;
+}
+export type TReducerNames = 'SET_HISTORY' | 'UPDATE_HISTORY' | 'UNDO' | 'REDO';

package/dist/types/image.d.ts

@@ -0,0 +1,48 @@
+import { IPosition, ISize, TStringMatrix } from "./general";
+export interface IOptionImageSize {
+    width?: number;
+    height?: number;
+}
+export interface IImageOptions extends IPosition, IOptionImageSize {
+}
+export interface IDrawImageArgs {
+    position: IArgumentImagePosition;
+    size?: TArgumentImageSize;
+}
+export interface IArgumentImagePosition extends IPosition {
+}
+export interface IPixelPosition extends IPosition {
+}
+export type TArgumentImageSize = IOptionImageSize | 'initial';
+export interface IImageSize extends ISize {
+}
+export type TRGBABuff = TByteRGBColor[];
+export type TByteRGBColor = [number, number, number, number];
+export type TBuff<T> = T[][];
+export type TQualityBuff = TStringMatrix;
+export type TRangeCommit = IPixelPosition[][];
+export type TFilterMethod = 'pixel';
+export interface IFilterOptions {
+    quality: number;
+}
+export declare const enum E_RGBA {
+    r = 0,
+    g = 1,
+    b = 2,
+    a = 3
+}
+export interface IExtendedImageDataModel {
+    imageData: ImageData;
+    size: ISize;
+}
+export interface IImageLoggingData {
+    imageData: ImageData;
+    size: ISize;
+    position: IPosition;
+}
+export interface IImageLoggingDataVague extends IImageLoggingData, IFilterOptions {
+}
+export interface IDrawImageProcessor {
+    draw(options?: IDrawImageArgs): Promise<any>;
+    vague(options: IImageOptions, filterOptions: IFilterOptions): Promise<IImageLoggingDataVague>;
+}

package/dist/types/log.d.ts

@@ -0,0 +1,13 @@
+export interface ILog<A, R, P> {
+    components: ILogItem<A>[];
+    services: ILogItem<R>[];
+    planed: ILogItem<P>[];
+}
+export interface ILogItem<TLogPrototype> {
+    info: ILogItemInfo;
+    prototype: TLogPrototype;
+}
+export interface ILogItemInfo {
+    name: string;
+    description: string;
+}

package/dist/types/pipette.d.ts

@@ -0,0 +1 @@
+export type TPipetteState = 'taken' | 'abandoned' | 'selected-color';

package/dist/types/project.d.ts

@@ -0,0 +1,38 @@
+import { IHistoryLine } from "./history";
+import { IImageLoggingData } from "./image";
+export declare class Project {
+    id: string;
+    name: string;
+    description: string;
+    state: {
+        current: IImageLoggingData;
+        history: IHistoryLine[];
+        cache: IHistoryLine[];
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+export interface IUpdateProject {
+    id?: string;
+    name?: string;
+    description?: string;
+    state?: {
+        current: IImageLoggingData;
+        history: IHistoryLine[];
+        cache: IHistoryLine[];
+    };
+    updatedAt?: string;
+}
+export interface IProjectModule {
+    getProjects(): Project[];
+    getProject(projectId: string): Project;
+    saveProjects(projects: Project[]): void;
+    saveProject(project: Project): void;
+    removeProject(projectId: string): void;
+    updateProject(project: Project): void;
+}
+export type TProjectModule = {
+    name: string;
+    instance: IProjectModule;
+};
+export type TProjectModuleName = 'LocalStorage' | 'File';

package/dist/utils/convert.d.ts

@@ -0,0 +1,12 @@
+import type { TByteRGBColor } from "../types/image";
+import type { THEXColor } from "../types/general";
+export declare class Convert {
+    static byteRGBToHEX(color: TByteRGBColor): THEXColor;
+    static rgbToHex(r: number, g: number, b: number): THEXColor;
+    static hexToRgb(hex: string): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    private static componentToHEX;
+}

package/dist/utils/filter.d.ts

@@ -0,0 +1,21 @@
+import { IExtendedImageDataModel, type IImageOptions, type IImageSize, type TBuff, type TRGBABuff } from "../types/image";
+import type { ISize, THEXColor } from '../types/general';
+export declare class Filter {
+    ctx: CanvasRenderingContext2D;
+    imageSize: IImageSize;
+    constructor(ctx: CanvasRenderingContext2D);
+    setImageSize(size: IImageSize): void;
+    copy(options: IImageOptions): ImageData;
+    copyExtendedModel(options: IImageOptions): IExtendedImageDataModel;
+    update(imgData: ImageData, options: IImageOptions): void;
+    clearEmptyPixels(imageData: ImageData): IExtendedImageDataModel;
+    getSizeOfSparseMatrix(RGBAMatrix: TBuff<number[]>, tempSize: ISize): ISize;
+    getBuffCollection(imageData: ImageData): {
+        rowRGBABuff: TRGBABuff;
+        hexBuff: `#${string}`[];
+        buff: TBuff<string>;
+    };
+    getBuff(hexBuff: THEXColor[]): TBuff<string>;
+    getRGBAMatrix(rowRGBABuff: TRGBABuff, size?: ISize): TBuff<number[]>;
+    getRowRGBABuff(imageData: ImageData): TRGBABuff;
+}

package/dist/utils/guid4.d.ts

@@ -0,0 +1,13 @@
+import { IGUID4 } from "../types/general";
+export declare class Guid4 {
+    stack: IGUID4[];
+    guid4: IGUID4;
+    constructor();
+    generate(): `${number}-${number}-${number}-${number}`;
+    get finite(): IGUID4;
+    private generateWithFactor;
+    private getFactor;
+    private get attempt();
+    private get Guid4();
+    private formating;
+}

package/dist/utils/project-file-serializer.d.ts

@@ -0,0 +1,13 @@
+import { Project } from "../types/project";
+export declare class ProjectFileSerializer {
+    private file;
+    private projects;
+    constructor(file: any);
+    private load;
+    saveProjects(projects: Project[]): void;
+    getProjects(): Project[];
+    getProject(projectId: string): Project;
+    saveProject(project: Project): void;
+    removeProject(projectId: string): void;
+    updateProject(project: Project): void;
+}

package/dist/web-component.d.ts

@@ -0,0 +1,30 @@
+import { TComponent } from "./types/general";
+export declare class WebComponentWrapper {
+    baseElement: HTMLDivElement;
+    editorWrapElement: HTMLDivElement;
+    stylesWrapElement: HTMLDivElement;
+    toolsWrapElement: HTMLDivElement;
+    constructor();
+    get base(): {
+        add: (component: TComponent, style?: HTMLStyleElement) => HTMLDivElement;
+    };
+    get editorWrap(): {
+        add: (component: TComponent, style?: HTMLStyleElement) => HTMLDivElement;
+    };
+    get stylesWrap(): {
+        add: (component: TComponent, style?: HTMLStyleElement) => HTMLDivElement;
+    };
+    get toolsWrap(): {
+        add: (component: TComponent, style?: HTMLStyleElement) => HTMLDivElement;
+    };
+    private _methods;
+    private _add;
+    private _baseStyle;
+}
+declare global {
+    interface HTMLElement {
+    }
+}
+export default class WebComponent extends HTMLElement {
+    constructor();
+}

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "canvas-editor-engine",
-  "version": "2.0.12",
+  "version": "2.0.13",
   "description": "CanvasEditorEngine library, use: [typescript] [canvas]",
-  "main": "dist/index.mjs.js",
+  "main": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "files": [
     "/dist"
   ],
+  "type": "module",
   "scripts": {
     "test": "node test/test.js",
     "build-ts": "tsc",
     "build": "npx webpack",
+    "build:rollup": "rollup -c",
     "realise": "npm version patch && npm publish"
   },
   "keywords": [
@@ -25,11 +27,15 @@
     "@types/node": "^22.7.4",
     "ts-loader": "^9.5.1",
     "typescript": "^5.7.2",
+    "typescript-declaration-webpack-plugin": "^0.3.0",
     "webpack": "^5.97.1",
-    "webpack-cli": "^5.1.4",
-    "typescript-declaration-webpack-plugin": "^0.3.0"
+    "webpack-cli": "^5.1.4"
   },
   "dependencies": {
-    "lodash": "^4.17.21"
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.1",
+    "lodash": "^4.17.21",
+    "rollup": "^4.28.1",
+    "tslib": "^2.8.1"
   }
 }