@plait/common 0.61.2 → 0.62.0-next.1

package/generators/index.d.ts

@@ -1,3 +1,3 @@
 export * from './generator';
 export * from './active.generator';
-export * from './image.generator';
+export * from '../image/image.generator';

package/image/image-base.component.d.ts

@@ -0,0 +1,17 @@
+import { PlaitBoard, PlaitElement } from '@plait/core';
+import { CommonImageItem } from '../utils';
+export declare abstract class ImageBaseComponent {
+    _imageItem: CommonImageItem;
+    _isFocus: boolean;
+    initialized: boolean;
+    element: PlaitElement;
+    set imageItem(value: CommonImageItem);
+    get imageItem(): CommonImageItem;
+    board: PlaitBoard;
+    set isFocus(value: boolean);
+    get isFocus(): boolean;
+    abstract afterImageItemChange(previous: CommonImageItem, current: CommonImageItem): void;
+    abstract nativeElement(): HTMLElement;
+    initialize(): void;
+    destroy(): void;
+}

package/image/image.generator.d.ts

@@ -0,0 +1,27 @@
+import { PlaitBoard, PlaitElement, RectangleClient } from '@plait/core';
+import { Generator, GeneratorExtraData, GeneratorOptions } from '../generators/generator';
+import { CommonImageItem } from '../utils';
+import { ActiveGenerator } from '../generators/active.generator';
+import { ImageComponentRef } from './with-image';
+export declare const FOREIGN_OBJECT_IMAGE_CLASS_NAME = "foreign-object-image";
+export declare const IMAGE_CONTAINER_CLASS_NAME = "plait-image-container";
+export interface ImageGeneratorOptions<T> {
+    getRectangle: (element: T) => RectangleClient;
+    getImageItem: (element: T) => CommonImageItem;
+}
+export declare class ImageGenerator<T extends PlaitElement = PlaitElement> extends Generator<T, GeneratorExtraData, ImageGeneratorOptions<T> & GeneratorOptions> {
+    board: PlaitBoard;
+    options: ImageGeneratorOptions<T>;
+    static key: string;
+    foreignObject: SVGForeignObjectElement;
+    imageComponentRef: ImageComponentRef;
+    activeGenerator: ActiveGenerator;
+    isFocus: boolean;
+    element: T;
+    constructor(board: PlaitBoard, options: ImageGeneratorOptions<T>);
+    canDraw(element: T): boolean;
+    draw(element: T): SVGGElement;
+    updateImage(nodeG: SVGGElement, previous: T, current: T): void;
+    setFocus(element: PlaitElement, isFocus: boolean): void;
+    destroy(): void;
+}

package/image/index.d.ts

@@ -0,0 +1,3 @@
+export * from './image-base.component';
+export * from './image.generator';
+export * from './with-image';

package/image/with-image.d.ts

@@ -0,0 +1,15 @@
+import { PlaitBoard, PlaitElement, RectangleClient } from '@plait/core';
+import { RenderComponentRef } from '../core/render-component';
+import { CommonImageItem } from '../utils/image';
+export interface PlaitImageBoard {
+    renderImage: (container: Element | DocumentFragment, props: ImageProps) => ImageComponentRef;
+}
+export declare const withImage: <T extends PlaitBoard = PlaitBoard>(board: T) => T & PlaitImageBoard;
+export type ImageComponentRef = RenderComponentRef<ImageProps>;
+export interface ImageProps {
+    board: PlaitBoard;
+    imageItem: CommonImageItem;
+    element: PlaitElement;
+    isFocus?: boolean;
+    getRectangle: () => RectangleClient;
+}

package/package.json

@@ -1,9 +1,7 @@
 {
   "name": "@plait/common",
-  "version": "0.61.2",
+  "version": "0.62.0-next.1",
   "peerDependencies": {
-    "@angular/common": "^17.2.4",
-    "@angular/core": "^17.2.4",
     "is-hotkey": "^0.2.0"
   },
   "dependencies": {

package/plugins/index.d.ts

@@ -1,3 +1,2 @@
 export * from './with-resize';
-export * from './text-options';
 export * from './with-group';

package/public-api.d.ts

@@ -4,8 +4,9 @@ export * from './transforms';
 export * from './shapes';
 export * from './plugins';
 export * from './utils';
-export * from './core/element-flavour';
-export * from './core/image-base.component';
-export * from './core/element-ref';
+export * from './image/image-base.component';
+export * from './core';
 export * from './algorithms';
+export * from './text';
+export * from './image';
 export * from './types';

package/text/index.d.ts

@@ -0,0 +1,4 @@
+export * from './text-manage';
+export * from './with-text';
+export * from './text-measure';
+export * from './types';

package/text/text-manage.d.ts

@@ -0,0 +1,41 @@
+import { PlaitBoard, Point, RectangleClient } from '@plait/core';
+import { Editor, Element, Operation } from 'slate';
+import { TextPlugin } from './with-text';
+import { TextComponentRef } from './with-text';
+export interface TextManageChangeData {
+    newText?: Element;
+    operations?: Operation[];
+    width: number;
+    height: number;
+}
+export declare class TextManage {
+    private board;
+    private options;
+    isEditing: boolean;
+    editor: Editor;
+    g: SVGGElement;
+    foreignObject: SVGForeignObjectElement;
+    textComponentRef: TextComponentRef;
+    constructor(board: PlaitBoard, options: {
+        getRectangle: () => RectangleClient;
+        onChange?: (data: TextManageChangeData) => void;
+        getRenderRectangle?: () => RectangleClient;
+        getMaxWidth?: () => number;
+        textPlugins?: TextPlugin[];
+    });
+    draw(text: Element): void;
+    updateRectangleWidth(width: number): void;
+    updateAngle(centerPoint: Point, angle?: number): void;
+    updateRectangle(rectangle?: RectangleClient): void;
+    updateText(newText: Element): void;
+    edit(callback?: () => void): () => void;
+    getSize: (element?: Element) => {
+        width: number;
+        height: number;
+    };
+    getText: () => import("slate").Descendant;
+    destroy(): void;
+}
+export declare const buildCompositionData: (editor: Editor, data: string) => {
+    children: any[];
+} | null;

package/text/text-measure.d.ts

@@ -0,0 +1,8 @@
+import { ParagraphElement } from './types';
+export declare function measureElement(element: ParagraphElement, options: {
+    fontSize: number;
+    fontFamily: string;
+}, containerMaxWidth?: number): {
+    width: number;
+    height: number;
+};

package/text/types.d.ts

@@ -0,0 +1,24 @@
+import { BaseElement } from 'slate';
+export declare enum Alignment {
+    left = "left",
+    center = "center",
+    right = "right"
+}
+export type CustomText = {
+    bold?: boolean;
+    italic?: boolean;
+    strike?: boolean;
+    code?: boolean;
+    text: string;
+    underlined?: boolean;
+    color?: string;
+    [`font-size`]?: string;
+};
+export interface LinkElement extends BaseElement {
+    type: 'link';
+    url: string;
+}
+export interface ParagraphElement extends BaseElement {
+    align?: Alignment;
+}
+export type CustomElement = ParagraphElement | LinkElement;

package/text/with-text.d.ts

@@ -0,0 +1,25 @@
+import { PlaitBoard, WithPluginOptions } from '@plait/core';
+import { Editor, Operation, Element as SlateElement } from 'slate';
+import { RenderComponentRef } from '../core/render-component';
+export interface PlaitTextBoard {
+    renderText: (container: Element | DocumentFragment, props: TextProps) => TextComponentRef;
+}
+export declare const withText: <T extends PlaitBoard = PlaitBoard>(board: T) => T & PlaitTextBoard;
+export type TextComponentRef = RenderComponentRef<TextProps>;
+export interface TextProps {
+    board: PlaitBoard;
+    text: SlateElement;
+    textPlugins?: TextPlugin[];
+    readonly?: boolean;
+    onChange?: (data: TextChangeData) => void;
+    afterInit?: (data: Editor) => void;
+    onComposition?: (data: CompositionEvent) => void;
+}
+export type TextChangeData = {
+    newText: SlateElement;
+    operations: Operation[];
+};
+export interface WithTextPluginOptions extends WithPluginOptions {
+    textPlugins?: TextPlugin[];
+}
+export type TextPlugin = (editor: Editor) => Editor;

package/transforms/index.d.ts

@@ -1,3 +1,2 @@
 export * from './property';
 export * from './align';
-export * from './text';

package/utils/image.d.ts

@@ -1,13 +1,9 @@
-import { ComponentType, PlaitBoard, PlaitElement } from '@plait/core';
-import { ImageBaseComponent } from '../core/image-base.component';
+import { PlaitBoard, PlaitElement } from '@plait/core';
 export interface CommonImageItem {
     url: string;
     width: number;
     height: number;
 }
-export interface WithCommonPluginOptions {
-    imageComponentType?: ComponentType<ImageBaseComponent>;
-}
 export declare const selectImage: (board: PlaitBoard, defaultImageWidth: number, handle: (commonImage: CommonImageItem) => void, acceptImageTypes?: string[]) => void;
 export declare const buildImage: (board: PlaitBoard, imageFile: File, defaultImageWidth: number, handle: (commonImage: CommonImageItem) => void) => Promise<void>;
 export declare const getElementOfFocusedImage: (board: PlaitBoard) => PlaitElement | undefined;

package/utils/text.d.ts

@@ -1,12 +1,15 @@
 import { PlaitBoard, PlaitElement } from '@plait/core';
-import { CustomText, TextManage } from '@plait/text';
+import { Element } from 'slate';
+import { TextManage } from '../text/text-manage';
+import { Alignment, CustomText } from '../text/types';
 export declare const getTextManages: (element: PlaitElement) => TextManage[];
 export declare const getFirstTextManage: (element: PlaitElement) => TextManage;
-export declare const getTextEditorsByElement: (element: PlaitElement) => (import("slate").BaseEditor & import("slate-angular").AngularEditor & import("slate-history").HistoryEditor)[];
-export declare const getFirstTextEditor: (element: PlaitElement) => import("slate").BaseEditor & import("slate-angular").AngularEditor & import("slate-history").HistoryEditor;
+export declare const getTextEditorsByElement: (element: PlaitElement) => import("slate").BaseEditor[];
+export declare const getFirstTextEditor: (element: PlaitElement) => import("slate").BaseEditor;
 export declare const findFirstTextEditor: (board: PlaitBoard) => null;
-export declare const getTextMarksByElement: (element: PlaitElement) => Omit<CustomText, "text">;
 export declare const getElementsText: (elements: PlaitElement[]) => string;
-export declare const getTextEditors: (board: PlaitBoard, elements?: PlaitElement[]) => (import("slate").BaseEditor & import("slate-angular").AngularEditor & import("slate-history").HistoryEditor)[] | undefined;
-export declare const getEditingTextEditor: (board: PlaitBoard, elements?: PlaitElement[]) => (import("slate").BaseEditor & import("slate-angular").AngularEditor & import("slate-history").HistoryEditor) | undefined;
+export declare const getTextEditors: (board: PlaitBoard, elements?: PlaitElement[]) => import("slate").BaseEditor[] | undefined;
+export declare const getEditingTextEditor: (board: PlaitBoard, elements?: PlaitElement[]) => import("slate").BaseEditor | undefined;
+export declare const buildText: (text: string | Element, align?: Alignment, properties?: Partial<CustomText>) => import("slate").BaseElement;
+export declare const getLineHeightByFontSize: (fontSize: number) => number;
 export declare const ELEMENT_TO_TEXT_MANAGES: WeakMap<PlaitElement, TextManage[]>;

package/core/image-base.component.d.ts

@@ -1,29 +0,0 @@
-import { ChangeDetectorRef, ElementRef, OnDestroy, OnInit } from '@angular/core';
-import { PlaitBoard, PlaitElement, RectangleClient } from '@plait/core';
-import { ActiveGenerator } from '../generators';
-import { CommonImageItem } from '../utils';
-import * as i0 from "@angular/core";
-export declare abstract class ImageBaseComponent implements OnInit, OnDestroy {
-    protected elementRef: ElementRef<HTMLElement>;
-    cdr: ChangeDetectorRef;
-    _imageItem: CommonImageItem;
-    _isFocus: boolean;
-    initialized: boolean;
-    activeGenerator: ActiveGenerator;
-    element: PlaitElement;
-    set imageItem(value: CommonImageItem);
-    get imageItem(): CommonImageItem;
-    board: PlaitBoard;
-    set isFocus(value: boolean);
-    get isFocus(): boolean;
-    get nativeElement(): HTMLElement;
-    abstract afterImageItemChange(previous: CommonImageItem, current: CommonImageItem): void;
-    getRectangle: () => RectangleClient;
-    hasResizeHandle: () => boolean;
-    constructor(elementRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
-    ngOnInit(): void;
-    drawFocus(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ImageBaseComponent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ImageBaseComponent, never, never, { "element": { "alias": "element"; "required": false; }; "imageItem": { "alias": "imageItem"; "required": false; }; "board": { "alias": "board"; "required": false; }; "isFocus": { "alias": "isFocus"; "required": false; }; "getRectangle": { "alias": "getRectangle"; "required": false; }; "hasResizeHandle": { "alias": "hasResizeHandle"; "required": false; }; }, {}, never, never, false, never>;
-}

package/esm2022/core/image-base.component.mjs

@@ -1,95 +0,0 @@
-import { Directive, Input } from '@angular/core';
-import { ACTIVE_STROKE_WIDTH, PlaitBoard, getSelectedElements, isSelectionMoving } from '@plait/core';
-import { ActiveGenerator } from '../generators';
-import { canResize, getElementOfFocusedImage } from '../utils';
-import * as i0 from "@angular/core";
-export class ImageBaseComponent {
-    set imageItem(value) {
-        this.afterImageItemChange(this._imageItem, value);
-        this._imageItem = value;
-        this.drawFocus();
-    }
-    get imageItem() {
-        return this._imageItem;
-    }
-    set isFocus(value) {
-        this._isFocus = value;
-        this.drawFocus();
-    }
-    get isFocus() {
-        return this._isFocus;
-    }
-    get nativeElement() {
-        return this.elementRef.nativeElement;
-    }
-    constructor(elementRef, cdr) {
-        this.elementRef = elementRef;
-        this.cdr = cdr;
-        this.initialized = false;
-    }
-    ngOnInit() {
-        this.activeGenerator = new ActiveGenerator(this.board, {
-            getStrokeWidth: () => {
-                const selectedElements = getSelectedElements(this.board);
-                if (!(selectedElements.length === 1 && !isSelectionMoving(this.board))) {
-                    return ACTIVE_STROKE_WIDTH;
-                }
-                else {
-                    return ACTIVE_STROKE_WIDTH;
-                }
-            },
-            getStrokeOpacity: () => {
-                const selectedElements = getSelectedElements(this.board);
-                if ((selectedElements.length === 1 && !isSelectionMoving(this.board)) || !selectedElements.length) {
-                    return 1;
-                }
-                else {
-                    return 0.5;
-                }
-            },
-            getRectangle: () => {
-                return this.getRectangle();
-            },
-            hasResizeHandle: () => {
-                const isSelectedImageElement = canResize(this.board, this.element);
-                const isSelectedImage = !!getElementOfFocusedImage(this.board);
-                return isSelectedImage || isSelectedImageElement;
-            }
-        });
-        this.initialized = true;
-    }
-    drawFocus() {
-        if (this.initialized) {
-            const activeG = PlaitBoard.getElementActiveHost(this.board);
-            this.activeGenerator.processDrawing(this.element, activeG, { selected: this._isFocus });
-        }
-    }
-    ngOnDestroy() {
-        if (this.activeGenerator) {
-            this.activeGenerator.destroy();
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: ImageBaseComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.2.4", type: ImageBaseComponent, inputs: { element: "element", imageItem: "imageItem", board: "board", isFocus: "isFocus", getRectangle: "getRectangle", hasResizeHandle: "hasResizeHandle" }, host: { classAttribute: "plait-image-container" }, ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: ImageBaseComponent, decorators: [{
-            type: Directive,
-            args: [{
-                    host: {
-                        class: 'plait-image-container'
-                    }
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }], propDecorators: { element: [{
-                type: Input
-            }], imageItem: [{
-                type: Input
-            }], board: [{
-                type: Input
-            }], isFocus: [{
-                type: Input
-            }], getRectangle: [{
-                type: Input
-            }], hasResizeHandle: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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

package/esm2022/generators/image.generator.mjs

@@ -1,59 +0,0 @@
-import { RectangleClient, createForeignObject, createG, setAngleForG, updateForeignObject } from '@plait/core';
-import { Generator } from './generator';
-import { WithCommonPluginKey } from '../constants';
-export class ImageGenerator extends Generator {
-    static { this.key = 'image-generator'; }
-    constructor(board, options) {
-        super(board, options);
-        this.board = board;
-        this.options = options;
-    }
-    canDraw(element, data) {
-        return !!this.options.getImageItem(element);
-    }
-    draw(element, viewContainerRef) {
-        const g = createG();
-        const foreignRectangle = this.options.getRectangle(element);
-        this.foreignObject = createForeignObject(foreignRectangle.x, foreignRectangle.y, foreignRectangle.width, foreignRectangle.height);
-        g.append(this.foreignObject);
-        const componentType = this.board.getPluginOptions(WithCommonPluginKey)
-            .imageComponentType;
-        if (!componentType) {
-            throw new Error('Not implement ImageBaseComponent error.');
-        }
-        this.componentRef = viewContainerRef.createComponent(componentType);
-        this.componentRef.instance.board = this.board;
-        this.componentRef.instance.imageItem = this.options.getImageItem(element);
-        this.componentRef.instance.element = element;
-        this.componentRef.instance.getRectangle = () => {
-            return this.options.getRectangle(element);
-        };
-        this.componentRef.instance.cdr.markForCheck();
-        this.foreignObject.append(this.componentRef.instance.nativeElement);
-        return g;
-    }
-    updateImage(nodeG, previous, current) {
-        if (previous !== current && this.componentRef) {
-            this.componentRef.instance.imageItem = this.options.getImageItem(current);
-            this.componentRef.instance.element = current;
-            this.componentRef.instance.getRectangle = () => {
-                return this.options.getRectangle(current);
-            };
-        }
-        const currentForeignObject = this.options.getRectangle(current);
-        updateForeignObject(this.g, currentForeignObject.width, currentForeignObject.height, currentForeignObject.x, currentForeignObject.y);
-        if (currentForeignObject && current.angle) {
-            setAngleForG(this.g, RectangleClient.getCenterPoint(currentForeignObject), current.angle);
-        }
-        // solve image lose on move node
-        if (this.foreignObject.children.length === 0) {
-            this.foreignObject.append(this.componentRef.instance.nativeElement);
-        }
-        this.componentRef?.instance.cdr.markForCheck();
-    }
-    destroy() {
-        super.destroy();
-        this.componentRef?.destroy();
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image.generator.js","sourceRoot":"","sources":["../../../../packages/common/src/generators/image.generator.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    PlaitBoard,\n    PlaitElement,\n    PlaitOptionsBoard,\n    RectangleClient,\n    createForeignObject,\n    createG,\n    setAngleForG,\n    updateForeignObject\n} from '@plait/core';\nimport { Generator, GeneratorOptions } from './generator';\nimport { ComponentRef, ViewContainerRef } from '@angular/core';\nimport { ImageBaseComponent } from '../core/image-base.component';\nimport { CommonImageItem, WithCommonPluginOptions } from '../utils';\nimport { WithCommonPluginKey } from '../constants';\nexport interface ShapeData {\n    viewContainerRef: ViewContainerRef;\n}\n\nexport interface ImageGeneratorOptions<T> {\n    getRectangle: (element: T) => RectangleClient;\n    getImageItem: (element: T) => CommonImageItem;\n}\n\nexport class ImageGenerator<T extends PlaitElement = PlaitElement> extends Generator<\n    T,\n    ViewContainerRef,\n    ImageGeneratorOptions<T> & GeneratorOptions\n> {\n    static key = 'image-generator';\n\n    foreignObject!: SVGForeignObjectElement;\n\n    componentRef!: ComponentRef<ImageBaseComponent>;\n\n    constructor(public board: PlaitBoard, public options: ImageGeneratorOptions<T>) {\n        super(board, options);\n    }\n\n    canDraw(element: T, data: ViewContainerRef): boolean {\n        return !!this.options.getImageItem(element);\n    }\n\n    draw(element: T, viewContainerRef: ViewContainerRef): SVGGElement {\n        const g = createG();\n        const foreignRectangle = this.options.getRectangle(element);\n        this.foreignObject = createForeignObject(foreignRectangle.x, foreignRectangle.y, foreignRectangle.width, foreignRectangle.height);\n        g.append(this.foreignObject);\n        const componentType = (this.board as PlaitOptionsBoard).getPluginOptions<WithCommonPluginOptions>(WithCommonPluginKey)\n            .imageComponentType;\n        if (!componentType) {\n            throw new Error('Not implement ImageBaseComponent error.');\n        }\n        this.componentRef = viewContainerRef.createComponent(componentType);\n        this.componentRef.instance.board = this.board;\n\n        this.componentRef.instance.imageItem = this.options.getImageItem(element);\n        this.componentRef.instance.element = element;\n        this.componentRef.instance.getRectangle = () => {\n            return this.options.getRectangle(element);\n        };\n        this.componentRef.instance.cdr.markForCheck();\n        this.foreignObject.append(this.componentRef!.instance.nativeElement);\n        return g;\n    }\n\n    updateImage(nodeG: SVGGElement, previous: T, current: T) {\n        if (previous !== current && this.componentRef) {\n            this.componentRef.instance.imageItem = this.options.getImageItem(current);\n            this.componentRef.instance.element = current;\n            this.componentRef!.instance.getRectangle = () => {\n                return this.options.getRectangle(current);\n            };\n        }\n        const currentForeignObject = this.options.getRectangle(current);\n        updateForeignObject(\n            this.g!,\n            currentForeignObject.width,\n            currentForeignObject.height,\n            currentForeignObject.x,\n            currentForeignObject.y\n        );\n        if (currentForeignObject && current.angle) {\n            setAngleForG(this.g!, RectangleClient.getCenterPoint(currentForeignObject), current.angle);\n        }\n        // solve image lose on move node\n        if (this.foreignObject.children.length === 0) {\n            this.foreignObject.append(this.componentRef!.instance.nativeElement);\n        }\n        this.componentRef?.instance.cdr.markForCheck();\n    }\n\n    destroy(): void {\n        super.destroy();\n        this.componentRef?.destroy();\n    }\n}\n"]}

package/esm2022/plugins/text-options.mjs

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dC1vcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL3NyYy9wbHVnaW5zL3RleHQtb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgV2l0aFBsdWdpbk9wdGlvbnMgfSBmcm9tICdAcGxhaXQvY29yZSc7XG5pbXBvcnQgeyBUZXh0UGx1Z2luIH0gZnJvbSAnQHBsYWl0L3RleHQnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFdpdGhUZXh0T3B0aW9ucyBleHRlbmRzIFdpdGhQbHVnaW5PcHRpb25zIHtcbiAgICB0ZXh0UGx1Z2lucz86IFRleHRQbHVnaW5bXTtcbn1cbiJdfQ==

package/esm2022/transforms/text.mjs

@@ -1,71 +0,0 @@
-import { getSelectedElements } from '@plait/core';
-import { AlignEditor, MarkTypes, PlaitMarkEditor } from '@plait/text';
-import { Editor, Transforms as SlateTransforms } from 'slate';
-import { findFirstTextEditor, getTextEditors, getTextEditorsByElement } from '../utils/text';
-const setTextMarks = (board, mark) => {
-    const selectedElements = getSelectedElements(board);
-    if (selectedElements.length) {
-        const firstEditor = findFirstTextEditor(board);
-        if (!firstEditor) {
-            return;
-        }
-        const activeMarks = PlaitMarkEditor.getMarks(firstEditor);
-        const elements = selectedElements.filter(element => {
-            const editors = getTextEditorsByElement(element);
-            return editors.some(editor => {
-                const elementMarks = PlaitMarkEditor.getMarks(editor);
-                return elementMarks[mark] === activeMarks[mark];
-            });
-        });
-        const editors = getTextEditors(board, elements);
-        if (editors && editors.length) {
-            editors.forEach(editor => {
-                PlaitMarkEditor.toggleMark(editor, mark);
-            });
-        }
-    }
-};
-const setFontSize = (board, size, defaultFontSize) => {
-    const editors = getTextEditors(board);
-    if (editors && editors.length) {
-        const selectedElements = getSelectedElements(board);
-        editors.forEach(editor => {
-            let finalDefaultFontSize;
-            if (typeof defaultFontSize === 'function') {
-                const element = selectedElements.find(element => {
-                    const textEditors = getTextEditorsByElement(element);
-                    return textEditors.includes(editor);
-                });
-                finalDefaultFontSize = defaultFontSize(element);
-            }
-            else {
-                finalDefaultFontSize = defaultFontSize;
-            }
-            PlaitMarkEditor.setFontSizeMark(editor, size, finalDefaultFontSize);
-        });
-    }
-};
-const setTextColor = (board, color, textSelection) => {
-    const editors = getTextEditors(board);
-    if (editors && editors.length) {
-        editors.forEach(editor => {
-            if (textSelection) {
-                SlateTransforms.select(editor, textSelection);
-            }
-            if (color === 'transparent') {
-                Editor.removeMark(editor, MarkTypes.color);
-            }
-            else {
-                PlaitMarkEditor.setColorMark(editor, color);
-            }
-        });
-    }
-};
-const setTextAlign = (board, align) => {
-    const editors = getTextEditors(board);
-    if (editors && editors.length) {
-        editors.forEach(editor => AlignEditor.setAlign(editor, align));
-    }
-};
-export const TextTransforms = { setTextAlign, setTextColor, setFontSize, setTextMarks };
-//# sourceMappingURL=data:application/json;base64,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

package/generators/image.generator.d.ts

@@ -1,24 +0,0 @@
-import { PlaitBoard, PlaitElement, RectangleClient } from '@plait/core';
-import { Generator, GeneratorOptions } from './generator';
-import { ComponentRef, ViewContainerRef } from '@angular/core';
-import { ImageBaseComponent } from '../core/image-base.component';
-import { CommonImageItem } from '../utils';
-export interface ShapeData {
-    viewContainerRef: ViewContainerRef;
-}
-export interface ImageGeneratorOptions<T> {
-    getRectangle: (element: T) => RectangleClient;
-    getImageItem: (element: T) => CommonImageItem;
-}
-export declare class ImageGenerator<T extends PlaitElement = PlaitElement> extends Generator<T, ViewContainerRef, ImageGeneratorOptions<T> & GeneratorOptions> {
-    board: PlaitBoard;
-    options: ImageGeneratorOptions<T>;
-    static key: string;
-    foreignObject: SVGForeignObjectElement;
-    componentRef: ComponentRef<ImageBaseComponent>;
-    constructor(board: PlaitBoard, options: ImageGeneratorOptions<T>);
-    canDraw(element: T, data: ViewContainerRef): boolean;
-    draw(element: T, viewContainerRef: ViewContainerRef): SVGGElement;
-    updateImage(nodeG: SVGGElement, previous: T, current: T): void;
-    destroy(): void;
-}

package/plugins/text-options.d.ts

@@ -1,5 +0,0 @@
-import { WithPluginOptions } from '@plait/core';
-import { TextPlugin } from '@plait/text';
-export interface WithTextOptions extends WithPluginOptions {
-    textPlugins?: TextPlugin[];
-}

package/transforms/text.d.ts

@@ -1,9 +0,0 @@
-import { PlaitBoard, PlaitElement } from '@plait/core';
-import { Alignment, FontSizes, MarkTypes } from '@plait/text';
-import { BaseRange } from 'slate';
-export declare const TextTransforms: {
-    setTextAlign: (board: PlaitBoard, align: Alignment) => void;
-    setTextColor: (board: PlaitBoard, color: string, textSelection?: BaseRange) => void;
-    setFontSize: (board: PlaitBoard, size: FontSizes, defaultFontSize: number | ((element: PlaitElement) => number | undefined)) => void;
-    setTextMarks: (board: PlaitBoard, mark: MarkTypes) => void;
-};