editor-svg 1.0.2 → 1.0.3

package/dist/src/editor/interface/Separator.d.ts

@@ -0,0 +1,4 @@
+export interface ISeparatorOption {
+    strokeStyle?: string;
+    lineWidth?: number;
+}

package/dist/src/editor/interface/Text.d.ts

@@ -0,0 +1,13 @@
+import { TextDecorationStyle } from '../dataset/enum/Text';
+export interface ITextMetrics {
+    width: number;
+    actualBoundingBoxAscent: number;
+    actualBoundingBoxDescent: number;
+    actualBoundingBoxLeft: number;
+    actualBoundingBoxRight: number;
+    fontBoundingBoxAscent: number;
+    fontBoundingBoxDescent: number;
+}
+export interface ITextDecoration {
+    style?: TextDecorationStyle;
+}

package/dist/src/editor/interface/Title.d.ts

@@ -0,0 +1,26 @@
+import { EditorZone } from '../dataset/enum/Editor';
+import { IElement } from './Element';
+export interface ITitleSizeOption {
+    defaultFirstSize?: number;
+    defaultSecondSize?: number;
+    defaultThirdSize?: number;
+    defaultFourthSize?: number;
+    defaultFifthSize?: number;
+    defaultSixthSize?: number;
+}
+export type ITitleOption = ITitleSizeOption & {};
+export interface ITitleRule {
+    deletable?: boolean;
+    disabled?: boolean;
+}
+export type ITitle = ITitleRule & {
+    conceptId?: string;
+};
+export interface IGetTitleValueOption {
+    conceptId: string;
+}
+export type IGetTitleValueResult = (ITitle & {
+    value: string | null;
+    elementList: IElement[];
+    zone: EditorZone;
+})[];

package/dist/src/editor/interface/Watermark.d.ts

@@ -0,0 +1,15 @@
+import { NumberType } from '../dataset/enum/Common';
+import { WatermarkType } from '../dataset/enum/Watermark';
+export interface IWatermark {
+    data: string;
+    type?: WatermarkType;
+    width?: number;
+    height?: number;
+    color?: string;
+    opacity?: number;
+    size?: number;
+    font?: string;
+    repeat?: boolean;
+    numberType?: NumberType;
+    gap?: [horizontal: number, vertical: number];
+}

package/dist/src/editor/interface/WhiteSpace.d.ts

@@ -0,0 +1,5 @@
+export interface IWhiteSpaceOption {
+    disabled?: boolean;
+    color?: string;
+    radius?: number;
+}

package/{src/editor/interface/Zone.ts → dist/src/editor/interface/Zone.d.ts}

@@ -1,3 +1,3 @@
-export interface IZoneOption {
-  tipDisabled?: boolean
-}
+export interface IZoneOption {
+    tipDisabled?: boolean;
+}

package/dist/src/editor/interface/contextmenu/ContextMenu.d.ts

@@ -0,0 +1,73 @@
+import { Command } from '../../core/command/Command';
+import { EditorZone } from '../../dataset/enum/Editor';
+import { DeepRequired } from '../Common';
+import { IEditorOption } from '../Editor';
+import { IElement } from '../Element';
+export interface IContextMenuContext {
+    startElement: IElement | null;
+    endElement: IElement | null;
+    isReadonly: boolean;
+    editorHasSelection: boolean;
+    editorTextFocus: boolean;
+    isInTable: boolean;
+    isCrossRowCol: boolean;
+    zone: EditorZone;
+    trIndex: number | null;
+    tdIndex: number | null;
+    tableElement: IElement | null;
+    options: DeepRequired<IEditorOption>;
+}
+export interface IRegisterContextMenu {
+    key?: string;
+    i18nPath?: string;
+    isDivider?: boolean;
+    icon?: string;
+    name?: string;
+    shortCut?: string;
+    disable?: boolean;
+    when?: (payload: IContextMenuContext) => boolean;
+    callback?: (command: Command, context: IContextMenuContext) => void;
+    childMenus?: IRegisterContextMenu[];
+}
+export interface IContextmenuLang {
+    global: {
+        cut: string;
+        copy: string;
+        paste: string;
+        selectAll: string;
+        print: string;
+    };
+    control: {
+        delete: string;
+    };
+    hyperlink: {
+        delete: string;
+        cancel: string;
+        edit: string;
+    };
+    image: {
+        change: string;
+        saveAs: string;
+        textWrap: string;
+        textWrapType: {
+            embed: string;
+            upDown: string;
+            surround: string;
+            floatTop: string;
+            floatBottom: string;
+        };
+    };
+    table: {
+        insertRowCol: string;
+        insertTopRow: string;
+        insertBottomRow: string;
+        insertLeftCol: string;
+        insertRightCol: string;
+        deleteRowCol: string;
+        deleteRow: string;
+        deleteCol: string;
+        deleteTable: string;
+        mergeCell: string;
+        mergeCancelCell: string;
+    };
+}

package/dist/src/editor/interface/i18n/I18n.d.ts

@@ -0,0 +1,6 @@
+import { IDatePickerLang } from '../../core/draw/particle/date/DatePicker';
+import { IContextmenuLang } from '../contextmenu/ContextMenu';
+export interface ILang {
+    contextmenu: IContextmenuLang;
+    datePicker: IDatePickerLang;
+}

package/dist/src/editor/interface/shortcut/Shortcut.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../../core/command/Command';
+import { KeyMap } from '../../dataset/enum/KeyMap';
+export interface IRegisterShortcut {
+    key: KeyMap;
+    ctrl?: boolean;
+    meta?: boolean;
+    mod?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    isGlobal?: boolean;
+    callback?: (command: Command) => void;
+    disable?: boolean;
+}

package/dist/src/editor/interface/table/Colgroup.d.ts

@@ -0,0 +1,4 @@
+export interface IColgroup {
+    id?: string;
+    width: number;
+}

package/dist/src/editor/interface/table/Table.d.ts

@@ -0,0 +1,8 @@
+import { IPadding } from '../Common';
+export interface ITableOption {
+    tdPadding?: IPadding;
+    defaultTrMinHeight?: number;
+    defaultColMinWidth?: number;
+    defaultBorderColor?: string;
+    overflow?: boolean;
+}

package/dist/src/editor/interface/table/Td.d.ts

@@ -0,0 +1,35 @@
+import { VerticalAlign } from '../../dataset/enum/VerticalAlign';
+import { TdBorder, TdSlash } from '../../dataset/enum/table/Table';
+import { IElement, IElementPosition } from '../Element';
+import { IRow } from '../Row';
+export interface ITd {
+    conceptId?: string;
+    id?: string;
+    extension?: unknown;
+    externalId?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    colspan: number;
+    rowspan: number;
+    value: IElement[];
+    trIndex?: number;
+    tdIndex?: number;
+    isLastRowTd?: boolean;
+    isLastColTd?: boolean;
+    isLastTd?: boolean;
+    rowIndex?: number;
+    colIndex?: number;
+    rowList?: IRow[];
+    positionList?: IElementPosition[];
+    verticalAlign?: VerticalAlign;
+    backgroundColor?: string;
+    borderTypes?: TdBorder[];
+    slashTypes?: TdSlash[];
+    mainHeight?: number;
+    realHeight?: number;
+    realMinHeight?: number;
+    disabled?: boolean;
+    deletable?: boolean;
+}

package/dist/src/editor/interface/table/Tr.d.ts

@@ -0,0 +1,10 @@
+import { ITd } from './Td';
+export interface ITr {
+    id?: string;
+    extension?: unknown;
+    externalId?: string;
+    height: number;
+    tdList: ITd[];
+    minHeight?: number;
+    pagingRepeat?: boolean;
+}

package/dist/src/editor/utils/clipboard.d.ts

@@ -0,0 +1,13 @@
+import { DeepRequired } from '../interface/Common';
+import { IEditorOption } from '../interface/Editor';
+import { IElement } from '../interface/Element';
+export interface IClipboardData {
+    text: string;
+    elementList: IElement[];
+}
+export declare function setClipboardData(data: IClipboardData): void;
+export declare function getClipboardData(): IClipboardData | null;
+export declare function removeClipboardData(): void;
+export declare function writeClipboardItem(text: string, html: string, elementList: IElement[]): Promise<void>;
+export declare function writeElementList(elementList: IElement[], options: DeepRequired<IEditorOption>): Promise<void>;
+export declare function getIsClipboardContainFile(clipboardData: DataTransfer): boolean;

package/dist/src/editor/utils/element.d.ts

@@ -0,0 +1,57 @@
+import { LocationPosition } from '../dataset/enum/Common';
+import { RowFlex } from '../dataset/enum/Row';
+import { DeepRequired } from '../interface/Common';
+import { IEditorOption } from '../interface/Editor';
+import { IElement } from '../interface/Element';
+export declare function unzipElementList(elementList: IElement[]): IElement[];
+interface IFormatElementListOption {
+    isHandleFirstElement?: boolean;
+    isForceCompensation?: boolean;
+    editorOptions: DeepRequired<IEditorOption>;
+}
+export declare function formatElementList(elementList: IElement[], options: IFormatElementListOption): void;
+export declare function isSameElementExceptValue(source: IElement, target: IElement): boolean;
+interface IPickElementOption {
+    extraPickAttrs?: Array<keyof IElement>;
+}
+export declare function pickElementAttr(payload: IElement, option?: IPickElementOption): IElement;
+interface IZipElementListOption {
+    extraPickAttrs?: Array<keyof IElement>;
+    isClassifyArea?: boolean;
+    isClone?: boolean;
+}
+export declare function zipElementList(payload: IElement[], options?: IZipElementListOption): IElement[];
+export declare function convertTextAlignToRowFlex(node: HTMLElement): RowFlex;
+export declare function convertRowFlexToTextAlign(rowFlex: RowFlex): RowFlex.LEFT | RowFlex.CENTER | RowFlex.RIGHT | RowFlex.JUSTIFY | "justify";
+export declare function convertRowFlexToJustifyContent(rowFlex: RowFlex): "center" | "flex-start" | "flex-end" | "space-between";
+export declare function isTextLikeElement(element: IElement): boolean;
+export declare function isTextElement(element: IElement): boolean;
+export declare function getElementListText(elementList: IElement[]): string;
+export declare function getAnchorElement(elementList: IElement[], anchorIndex: number): IElement | null;
+export interface IFormatElementContextOption {
+    isBreakWhenWrap?: boolean;
+    ignoreContextKeys?: Array<keyof IElement>;
+    editorOptions?: DeepRequired<IEditorOption>;
+}
+export declare function formatElementContext(sourceElementList: IElement[], formatElementList: IElement[], anchorIndex: number, options?: IFormatElementContextOption): void;
+export declare function convertElementToDom(element: IElement, options: DeepRequired<IEditorOption>): HTMLElement;
+export declare function splitListElement(elementList: IElement[]): Map<number, IElement[]>;
+export interface IElementListGroupRowFlex {
+    rowFlex: RowFlex | null;
+    data: IElement[];
+}
+export declare function groupElementListByRowFlex(elementList: IElement[]): IElementListGroupRowFlex[];
+export declare function createDomFromElementList(elementList: IElement[], options?: IEditorOption): HTMLDivElement;
+export declare function convertTextNodeToElement(textNode: Element | Node): IElement | null;
+export interface IGetElementListByHTMLOption {
+    innerWidth: number;
+}
+export declare function getElementListByHTML(htmlText: string, options: IGetElementListByHTMLOption): IElement[];
+export declare function getTextFromElementList(elementList: IElement[]): string;
+export declare function getSlimCloneElementList(elementList: IElement[]): IElement[];
+export declare function getIsBlockElement(element?: IElement): boolean;
+export declare function replaceHTMLElementTag(oldDom: HTMLElement, tagName: keyof HTMLElementTagNameMap): HTMLElement;
+export declare function pickSurroundElementList(elementList: IElement[]): IElement[];
+export declare function deleteSurroundElementList(elementList: IElement[], pageNo: number): void;
+export declare function getNonHideElementIndex(elementList: IElement[], index: number, position?: LocationPosition): number;
+export {};

package/dist/src/editor/utils/hotkey.d.ts

@@ -0,0 +1 @@
+export declare function isMod(evt: KeyboardEvent | MouseEvent): boolean;

package/dist/src/editor/utils/index.d.ts

@@ -0,0 +1,34 @@
+import { IElementFillRect } from '../interface/Element';
+export declare function debounce<T extends unknown[]>(func: (...arg: T) => unknown, delay: number): (this: unknown, ...args: T) => void;
+export declare function throttle<T extends unknown[]>(func: (...arg: T) => unknown, delay: number): (this: unknown, ...args: T) => void;
+export declare function deepCloneOmitKeys<T, K>(obj: T, omitKeys: (keyof K)[]): T;
+export declare function deepClone<T>(obj: T): T;
+export declare function isBody(node: Element): boolean;
+export declare function findParent(node: Element, filterFn: Function, includeSelf: boolean): Element | null;
+export declare function getUUID(): string;
+export declare function splitText(text: string): string[];
+export declare function downloadFile(href: string, fileName: string): void;
+export declare function threeClick(dom: HTMLElement, fn: (evt: MouseEvent) => void): void;
+export declare function isObject(type: unknown): type is Record<string, unknown>;
+export declare function isArray(type: unknown): type is Array<unknown>;
+export declare function isNumber(type: unknown): type is number;
+export declare function isString(type: unknown): type is string;
+export declare function mergeObject<T>(source: T, target: T): T;
+export declare function nextTick(fn: Function): void;
+export declare function convertNumberToChinese(num: number): string;
+export declare function cloneProperty<T>(properties: (keyof T)[], sourceElement: T, targetElement: T): void;
+export declare function deleteProperty<T>(sourceKeys: T[], deleteKeys: T[]): void;
+export declare function pickObject<T>(object: T, pickKeys: (keyof T)[]): T;
+export declare function omitObject<T>(object: T, omitKeys: (keyof T)[]): T;
+export declare function convertStringToBase64(input: string): string;
+export declare function findScrollContainer(element: HTMLElement): HTMLElement;
+export declare function isArrayEqual(arr1: unknown[], arr2: unknown[]): boolean;
+export declare function isObjectEqual(obj1: unknown, obj2: unknown): boolean;
+export declare function isRectIntersect(rect1: IElementFillRect, rect2: IElementFillRect): boolean;
+export declare function isNonValue(value: unknown): boolean;
+export declare function normalizeLineBreak(text: string): string;
+export declare function indexOf(source: string, search: string | RegExp, fromIndex?: number): {
+    index: number;
+    length: number;
+};
+export declare function scrollIntoView(container: HTMLElement, selected: HTMLElement): void;

package/dist/src/editor/utils/option.d.ts

@@ -0,0 +1,3 @@
+import { DeepRequired } from '../interface/Common';
+import { IEditorOption } from '../interface/Editor';
+export declare function mergeOption(options?: IEditorOption): DeepRequired<IEditorOption>;

package/dist/src/editor/utils/paragraph.d.ts

@@ -0,0 +1,8 @@
+import { IElement } from '../interface/Element';
+/**
+ * 获取段落索引
+ * @param elementList - 元素列表
+ * @param index - 目标索引
+ * @returns 段落索引
+ */
+export declare function getParagraphNo(elementList: IElement[], index: number): number;

package/dist/src/editor/utils/print.d.ts

@@ -0,0 +1,7 @@
+import { PaperDirection } from '../dataset/enum/Editor';
+export interface IPrintImageBase64Option {
+    width: number;
+    height: number;
+    direction?: PaperDirection;
+}
+export declare function printImageBase64(base64List: string[], options: IPrintImageBase64Option): void;

package/dist/src/editor/utils/ua.d.ts

@@ -0,0 +1,4 @@
+export declare const isApple: boolean;
+export declare const isIOS: boolean;
+export declare const isMobile: boolean;
+export declare const isFirefox: boolean;

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "editor-svg",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
   "description": "基于canvas-editor的二次开发",
   "keywords": [
     "editor-svg"
   ],
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "package.json"
+  ],
   "author": "coderyang",
   "license": "MIT",
   "publishConfig": {

package/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 2
-end_of_line = lf
-trim_trailing_whitespace = true
-insert_final_newline = false

package/.eslintrc

@@ -1,46 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "plugins": ["@typescript-eslint"],
-  "parserOptions": {
-    "ecmaVersion": 6,
-    "sourceType": "module"
-  },
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/eslint-recommended",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "env": {
-    "browser": true
-  },
-  "globals": {
-    "process": true
-  },
-  "rules": {
-    "linebreak-style": 0,
-    "no-console": 0,
-    "no-debugger": 0,
-    "no-useless-escape": "off",
-    "@typescript-eslint/no-explicit-any": 0,
-    "@typescript-eslint/no-empty-interface": 0,
-    "@typescript-eslint/no-this-alias": 0,
-    "@typescript-eslint/ban-ts-comment": 0,
-    "@typescript-eslint/explicit-module-boundary-types": 0,
-    "@typescript-eslint/no-non-null-assertion": 0,
-    "@typescript-eslint/ban-types": [1, {
-      "types": {
-        "Function": false,
-        "{}": false
-      },
-      "extendDefaults": true
-    }],
-    "no-constant-condition": ["error", {
-      "checkLoops": false
-    }],
-    "semi": [1, "never"],
-    "quotes": [1, "single", {
-      "allowTemplateLiterals": true
-    }]
-  },
-  "ignorePatterns": ["node_modules", "dist", "index.html"]
-}

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "semi": false,
-  "singleQuote": true,
-  "printWidth": 80,
-  "trailingComma": "none",
-  "arrowParens": "avoid",
-  "endOfLine": "lf"
-}

package/AGENTS.md

@@ -1,186 +0,0 @@
-# Canvas Editor - Agent Development Guide
-
-This guide provides essential information for agentic coding agents working on the canvas-editor repository.
-
-## Project Overview
-
-Canvas Editor is a TypeScript-based rich text editor library that renders content using HTML5 Canvas/SVG. It's built as an ES module with comprehensive TypeScript support and follows modern development practices.
-
-## Development Commands
-
-### Essential Commands
-```bash
-# Development
-npm run dev                    # Start Vite dev server
-npm run serve                  # Preview production build
-
-# Building (includes lint + type check)
-npm run lib                    # Build library for distribution
-npm run build                  # Build application
-
-# Code Quality
-npm run lint                   # Run ESLint
-npm run type:check            # TypeScript type checking
-
-# Testing
-npm run cypress:open          # Open Cypress test runner interactively
-npm run cypress:run           # Run Cypress tests headless
-```
-
-### Pre-commit Hooks
-- Automatically runs `npm run lint && npm run type:check` before commits
-- Commit messages must follow conventional commit format (feat:, fix:, docs:, etc.)
-
-## Code Style Guidelines
-
-### Formatting Rules
-- **No semicolons** - `semi: [1, "never"]`
-- **Single quotes** - `quotes: [1, "single"]`
-- **2-space indentation** - No tabs
-- **80 character line limit** - `printWidth: 80`
-- **No trailing commas** - `trailingComma: "none"`
-- **Arrow function parentheses avoided** - `arrowParens: "avoid"`
-- **LF line endings** - `endOfLine: "lf"`
-
-### TypeScript Configuration
-- **Strict mode enabled** - All type checking enforced
-- **Target**: ESNext with modern features
-- **Module system**: ESNext modules
-- **Source maps**: Enabled for debugging
-- **Unused locals/parameters**: Checked and reported
-
-### ESLint Rules
-- `any` type allowed (`@typescript-eslint/no-explicit-any: 0`)
-- Console statements permitted
-- Debugger statements allowed
-- No explicit function return type required when inferred
-
-## Project Structure
-
-### Main Directories
-```
-src/
-├── editor/                    # Core editor library
-│   ├── index.ts              # Main entry point - exports Editor class
-│   ├── core/                 # Core functionality
-│   │   ├── draw/             # Canvas rendering engine
-│   │   ├── command/         # Command pattern implementation
-│   │   ├── listener/        # Event handling system
-│   │   └── ...
-│   ├── interface/            # TypeScript type definitions
-│   ├── dataset/             # Constants and enums
-│   │   ├── constant/        # Magic numbers and strings
-│   │   └── enum/           # TypeScript enums
-│   ├── utils/              # Editor-specific utilities
-│   └── assets/             # CSS-in-JS and images
-├── plugins/                 # Optional editor plugins
-├── components/              # Reusable UI components
-├── utils/                   # Shared utility functions
-└── assets/                  # Static assets
-```
-
-### Key Files
-- **Main entry**: `src/editor/index.ts` - Exports Editor class and utilities
-- **Package exports**: ES module and UMD builds with TypeScript definitions
-- **Node requirement**: `>=16.9.1`
-
-## Import Conventions
-
-### Module Imports
-- Use ES module imports: `import { Editor } from './editor'`
-- TypeScript interfaces: `import type { EditorInterface } from './interface'`
-- Relative imports with explicit extensions for non-TypeScript files
-
-### Import Organization
-1. External libraries (Node.js built-ins, npm packages)
-2. Internal modules (absolute imports from src/)
-3. Relative imports (sibling/parent directory imports)
-4. Type-only imports (use `import type` when possible)
-
-## Naming Conventions
-
-### Files and Directories
-- **PascalCase** for components and classes: `EditorManager.ts`
-- **camelCase** for utilities and functions: `formatText.ts`
-- **kebab-case** for directories when containing multiple words: `rich-text/`
-
-### Code Elements
-- **PascalCase** for classes and interfaces: `class Editor`, `interface EditorConfig`
-- **camelCase** for functions and variables: `formatText`, `currentSelection`
-- **UPPER_SNAKE_CASE** for constants: `MAX_CANVAS_WIDTH`, `DEFAULT_FONT_SIZE`
-- **PascalCase** for enums: `enum TextAlignment`
-
-## Error Handling
-
-### TypeScript Errors
-- Use strict TypeScript checking - prefer explicit types over `any`
-- Handle nullable types with optional chaining and nullish coalescing
-- Use union types for variant error states
-
-### Runtime Errors
-- Throw descriptive Error objects with context
-- Use try-catch blocks for external API calls
-- Validate user input in public API methods
-
-## Testing Guidelines
-
-### Cypress E2E Tests
-- Tests located in `cypress/` directory
-- Use `npm run cypress:open` for interactive test development
-- Use `npm run cypress:run` for CI/CD automated testing
-- Viewport set to 1366x720 for consistency
-
-### Test Organization
-- Group related tests in describe blocks
-- Use beforeEach for common setup
-- Write descriptive test names that explain the behavior
-- Test both happy path and error conditions
-
-## Build Process
-
-### Library Build
-- TypeScript compilation with strict checking
-- Vite bundling for ES module and UMD outputs
-- Automatic CSS-in-JS injection via plugin
-- Source maps generated for debugging
-
-### Quality Gates
-- Linting must pass before build completion
-- Type checking must pass before build completion
-- Pre-commit hooks enforce quality standards
-
-## API Design
-
-### Public API
-- Main Editor class exported from `src/editor/index.ts`
-- Fluent method chaining where appropriate
-- Consistent parameter ordering (required, then optional)
-- Comprehensive TypeScript definitions
-
-### Plugin System
-- Plugins in `src/plugins/` directory
-- Extend Editor functionality without modifying core
-- Follow established plugin patterns in codebase
-
-## Development Workflow
-
-1. **Start development**: `npm run dev`
-2. **Make changes**: Follow code style guidelines
-3. **Test changes**: Use Cypress for E2E testing
-4. **Quality check**: `npm run lint && npm run type:check`
-5. **Commit**: Pre-commit hooks will validate automatically
-6. **Build**: `npm run lib` for distribution build
-
-## Performance Considerations
-
-- Canvas rendering optimized for frequent updates
-- Minimal DOM manipulation - primarily Canvas-based
-- Efficient event handling with delegation patterns
-- Memory-conscious object pooling where appropriate
-
-## Security Notes
-
-- No external network requests in core library
-- Sanitize all user input before rendering
-- Avoid eval() and Function constructor usage
-- Validate configuration options in public API