mce 0.1.0

package/dist/utils/BSTree/BSTreeKV.d.ts

@@ -0,0 +1,210 @@
+import * as util from './utils';
+/**
+ * General binary search tree implementation.
+ *
+ * This interface allows one to search elements using a subset of their attributes (thus the
+ * tree can be used as an index for complex objects).
+ * The attributes required to define an ordering in the tree must be defined in the type K.
+ * Any additional attribute must be defined in the type V.
+ *
+ * @see BSTree
+ */
+export default class BSTreeKV<K, V extends K> {
+    private root;
+    private compare;
+    private nElements;
+    /**
+     * Creates an empty binary search tree.
+     * @class <p>A binary search tree is a binary tree in which each
+     * internal node stores an element such that the elements stored in the
+     * left subtree are less than it and the elements
+     * stored in the right subtree are greater.</p>
+     * <p>Formally, a binary search tree is a node-based binary tree data structure which
+     * has the following properties:</p>
+     * <ul>
+     * <li>The left subtree of a node contains only nodes with elements less
+     * than the node's element</li>
+     * <li>The right subtree of a node contains only nodes with elements greater
+     * than the node's element</li>
+     * <li>Both the left and right subtrees must also be binary search trees.</li>
+     * </ul>
+     * <p>If the inserted elements are custom objects a compare function must
+     * be provided at construction time, otherwise the <=, === and >= operators are
+     * used to compare elements. Example:</p>
+     * <pre>
+     * function compare(a, b) {
+     *  if (a is less than b by some ordering criterion) {
+     *     return -1;
+     *  } if (a is greater than b by the ordering criterion) {
+     *     return 1;
+     *  }
+     *  // a must be equal to b
+     *  return 0;
+     * }
+     * </pre>
+     * @constructor
+     * @param {function(Object,Object):number=} compareFunction optional
+     * function used to compare two elements. Must return a negative integer,
+     * zero, or a positive integer as the first argument is less than, equal to,
+     * or greater than the second.
+     */
+    constructor(compareFunction?: util.ICompareFunction<K>);
+    /**
+     * Adds the specified element to this tree if it is not already present.
+     * @param {Object} element the element to insert.
+     * @return {boolean} true if this tree did not already contain the specified element.
+     */
+    add(element: V): boolean;
+    /**
+     * Removes all of the elements from this tree.
+     */
+    clear(): void;
+    /**
+     * Returns true if this tree contains no elements.
+     * @return {boolean} true if this tree contains no elements.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the number of elements in this tree.
+     * @return {number} the number of elements in this tree.
+     */
+    size(): number;
+    /**
+     * Returns true if this tree contains the specified element.
+     * @param {Object} element element to search for.
+     * @return {boolean} true if this tree contains the specified element,
+     * false otherwise.
+     */
+    contains(element: K): boolean;
+    /**
+     * 搜索元素
+     * @param {Object} element The key to look for
+     * @return {Object} The value found or undefined if it was not found.
+     */
+    search(element: K): V | undefined;
+    /**
+     * 搜索最接近的元素
+     */
+    searchClosest(element: K, closestCompareFn: util.IClosestCompareFunction<K>): V | undefined;
+    /**
+     * Removes the specified element from this tree if it is present.
+     * @return {boolean} true if this tree contained the specified element.
+     */
+    remove(element: K): boolean;
+    /**
+     * Executes the provided function once for each element present in this tree in
+     * in-order.
+     * @param {function(Object):*} callback function to execute, it is invoked with one
+     * argument: the element value, to break the iteration you can optionally return false.
+     */
+    inorderTraversal(callback: util.ILoopFunction<V>): void;
+    /**
+     * Executes the provided function once for each element present in this tree in
+     * out-order.
+     * @param {function(Object):*} callback function to execute, it is invoked with one
+     * argument: the element value, to break the iteration you can optionally return false.
+     */
+    outorderTraversal(callback: util.ILoopFunction<V>): void;
+    /**
+     * Executes the provided function once for each element present in this tree in pre-order.
+     * @param {function(Object):*} callback function to execute, it is invoked with one
+     * argument: the element value, to break the iteration you can optionally return false.
+     */
+    preorderTraversal(callback: util.ILoopFunction<V>): void;
+    /**
+     * Executes the provided function once for each element present in this tree in post-order.
+     * @param {function(Object):*} callback function to execute, it is invoked with one
+     * argument: the element value, to break the iteration you can optionally return false.
+     */
+    postorderTraversal(callback: util.ILoopFunction<V>): void;
+    /**
+     * Executes the provided function once for each element present in this tree in
+     * level-order.
+     * @param {function(Object):*} callback function to execute, it is invoked with one
+     * argument: the element value, to break the iteration you can optionally return false.
+     */
+    levelTraversal(callback: util.ILoopFunction<V>): void;
+    /**
+     * Returns the minimum element of this tree.
+     * @return {*} the minimum element of this tree or undefined if this tree is
+     * is empty.
+     */
+    minimum(): V | undefined;
+    /**
+     * Returns the maximum element of this tree.
+     * @return {*} the maximum element of this tree or undefined if this tree is
+     * is empty.
+     */
+    maximum(): V | undefined;
+    /**
+     * Executes the provided function once for each element present in this tree in inorder.
+     * Equivalent to inorderTraversal.
+     * @param {function(Object):*} callback function to execute, it is
+     * invoked with one argument: the element value, to break the iteration you can
+     * optionally return false.
+     */
+    forEach(callback: util.ILoopFunction<V>): void;
+    /**
+     * Returns an array containing all of the elements in this tree in in-order.
+     * @return {Array} an array containing all of the elements in this tree in in-order.
+     */
+    toArray(): V[];
+    /**
+     * Returns the height of this tree.
+     * @return {number} the height of this tree or -1 if is empty.
+     */
+    height(): number;
+    /**
+     * @private
+     */
+    private searchClosestNode;
+    /**
+     * @private
+     */
+    private searchNode;
+    /**
+     * @private
+     */
+    private transplant;
+    /**
+     * @private
+     */
+    private removeNode;
+    /**
+     * @private
+     */
+    private inorderTraversalAux;
+    /**
+     * @private
+     */
+    private outorderTraversalAux;
+    /**
+     * @private
+     */
+    private levelTraversalAux;
+    /**
+     * @private
+     */
+    private preorderTraversalAux;
+    /**
+     * @private
+     */
+    private postorderTraversalAux;
+    /**
+     * @private
+     */
+    private minimumAux;
+    /**
+     * @private
+     */
+    private maximumAux;
+    /**
+     * @private
+     */
+    private heightAux;
+    private insertNode;
+    /**
+     * @private
+     */
+    private createNode;
+}

package/dist/utils/BSTree/LinkedList.d.ts

@@ -0,0 +1,179 @@
+import * as util from './utils';
+export interface ILinkedListNode<T> {
+    element: T;
+    next: ILinkedListNode<T> | null;
+}
+export default class LinkedList<T> {
+    /**
+     * First node in the list
+     * @type {Object}
+     * @private
+     */
+    firstNode: ILinkedListNode<T> | null;
+    /**
+     * Last node in the list
+     * @type {Object}
+     * @private
+     */
+    private lastNode;
+    /**
+     * Number of elements in the list
+     * @type {number}
+     * @private
+     */
+    private nElements;
+    /**
+     * Creates an empty Linked List.
+     * @class A linked list is a data structure consisting of a group of nodes
+     * which together represent a sequence.
+     * @constructor
+     */
+    constructor();
+    /**
+     * Adds an element to this list.
+     * @param {Object} item element to be added.
+     * @param {number=} index optional index to add the element. If no index is specified
+     * the element is added to the end of this list.
+     * @return {boolean} true if the element was added or false if the index is invalid
+     * or if the element is undefined.
+     */
+    add(item: T, index?: number): boolean;
+    /**
+     * Returns the first element in this list.
+     * @return {*} the first element of the list or undefined if the list is
+     * empty.
+     */
+    first(): T | undefined;
+    /**
+     * Returns the last element in this list.
+     * @return {*} the last element in the list or undefined if the list is
+     * empty.
+     */
+    last(): T | undefined;
+    /**
+     * Returns the element at the specified position in this list.
+     * @param {number} index desired index.
+     * @return {*} the element at the given index or undefined if the index is
+     * out of bounds.
+     */
+    elementAtIndex(index: number): T | undefined;
+    /**
+     * Returns the index in this list of the first occurrence of the
+     * specified element, or -1 if the List does not contain this element.
+     * <p>If the elements inside this list are
+     * not comparable with the === operator a custom equals function should be
+     * provided to perform searches, the function must receive two arguments and
+     * return true if they are equal, false otherwise. Example:</p>
+     *
+     * <pre>
+     * const petsAreEqualByName = function(pet1, pet2) {
+     *  return pet1.name === pet2.name;
+     * }
+     * </pre>
+     * @param {Object} item element to search for.
+     * @param {function(Object,Object):boolean=} equalsFunction Optional
+     * function used to check if two elements are equal.
+     * @return {number} the index in this list of the first occurrence
+     * of the specified element, or -1 if this list does not contain the
+     * element.
+     */
+    indexOf(item: T, equalsFunction?: util.IEqualsFunction<T>): number;
+    /**
+     * Returns true if this list contains the specified element.
+     * <p>If the elements inside the list are
+     * not comparable with the === operator a custom equals function should be
+     * provided to perform searches, the function must receive two arguments and
+     * return true if they are equal, false otherwise. Example:</p>
+     *
+     * <pre>
+     * const petsAreEqualByName = function(pet1, pet2) {
+     *  return pet1.name === pet2.name;
+     * }
+     * </pre>
+     * @param {Object} item element to search for.
+     * @param {function(Object,Object):boolean=} equalsFunction Optional
+     * function used to check if two elements are equal.
+     * @return {boolean} true if this list contains the specified element, false
+     * otherwise.
+     */
+    contains(item: T, equalsFunction?: util.IEqualsFunction<T>): boolean;
+    /**
+     * Removes the first occurrence of the specified element in this list.
+     * <p>If the elements inside the list are
+     * not comparable with the === operator a custom equals function should be
+     * provided to perform searches, the function must receive two arguments and
+     * return true if they are equal, false otherwise. Example:</p>
+     *
+     * <pre>
+     * const petsAreEqualByName = function(pet1, pet2) {
+     *  return pet1.name === pet2.name;
+     * }
+     * </pre>
+     * @param {Object} item element to be removed from this list, if present.
+     * @return {boolean} true if the list contained the specified element.
+     */
+    remove(item: T, equalsFunction?: util.IEqualsFunction<T>): boolean;
+    /**
+     * Removes all of the elements from this list.
+     */
+    clear(): void;
+    /**
+     * Returns true if this list is equal to the given list.
+     * Two lists are equal if they have the same elements in the same order.
+     * @param {LinkedList} other the other list.
+     * @param {function(Object,Object):boolean=} equalsFunction optional
+     * function used to check if two elements are equal. If the elements in the lists
+     * are custom objects you should provide a function, otherwise
+     * the === operator is used to check equality between elements.
+     * @return {boolean} true if this list is equal to the given list.
+     */
+    equals(other: any, equalsFunction?: util.IEqualsFunction<T>): boolean;
+    /**
+     * @private
+     */
+    private equalsAux;
+    /**
+     * Removes the element at the specified position in this list.
+     * @param {number} index given index.
+     * @return {*} removed element or undefined if the index is out of bounds.
+     */
+    deleteElementAtIndex(index: number): T | undefined;
+    /**
+     * Executes the provided function once for each element present in this list in order.
+     * @param {function(Object):*} callback function to execute, it is
+     * invoked with one argument: the element value, to break the iteration you can
+     * optionally return false.
+     */
+    forEach(callback: util.ILoopFunction<T>): void;
+    /**
+     * Reverses the order of the elements in this linked list (makes the last
+     * element first, and the first element last).
+     */
+    reverse(): void;
+    /**
+     * Returns an array containing all of the elements in this list in proper
+     * sequence.
+     * @return {Array.<*>} an array containing all of the elements in this list,
+     * in proper sequence.
+     */
+    toArray(): T[];
+    /**
+     * Returns the number of elements in this list.
+     * @return {number} the number of elements in this list.
+     */
+    size(): number;
+    /**
+     * Returns true if this list contains no elements.
+     * @return {boolean} true if this list contains no elements.
+     */
+    isEmpty(): boolean;
+    toString(): string;
+    /**
+     * @private
+     */
+    private nodeAtIndex;
+    /**
+     * @private
+     */
+    private createNode;
+}

package/dist/utils/BSTree/Queue.d.ts

@@ -0,0 +1,81 @@
+import * as util from './utils';
+export default class Queue<T> {
+    /**
+     * List containing the elements.
+     * @type collections.LinkedList
+     * @private
+     */
+    private list;
+    /**
+     * Creates an empty queue.
+     * @class A queue is a First-In-First-Out (FIFO) data structure, the first
+     * element added to the queue will be the first one to be removed. This
+     * implementation uses a linked list as a container.
+     * @constructor
+     */
+    constructor();
+    /**
+     * Inserts the specified element into the end of this queue.
+     * @param {Object} elem the element to insert.
+     * @return {boolean} true if the element was inserted, or false if it is undefined.
+     */
+    enqueue(elem: T): boolean;
+    /**
+     * Inserts the specified element into the end of this queue.
+     * @param {Object} elem the element to insert.
+     * @return {boolean} true if the element was inserted, or false if it is undefined.
+     */
+    add(elem: T): boolean;
+    /**
+     * Retrieves and removes the head of this queue.
+     * @return {*} the head of this queue, or undefined if this queue is empty.
+     */
+    dequeue(): T | undefined;
+    /**
+     * Retrieves, but does not remove, the head of this queue.
+     * @return {*} the head of this queue, or undefined if this queue is empty.
+     */
+    peek(): T | undefined;
+    /**
+     * Returns the number of elements in this queue.
+     * @return {number} the number of elements in this queue.
+     */
+    size(): number;
+    /**
+     * Returns true if this queue contains the specified element.
+     * <p>If the elements inside this stack are
+     * not comparable with the === operator, a custom equals function should be
+     * provided to perform searches, the function must receive two arguments and
+     * return true if they are equal, false otherwise. Example:</p>
+     *
+     * <pre>
+     * const petsAreEqualByName (pet1, pet2) {
+     *  return pet1.name === pet2.name;
+     * }
+     * </pre>
+     * @param {Object} elem element to search for.
+     * @param {function(Object,Object):boolean=} equalsFunction optional
+     * function to check if two elements are equal.
+     * @return {boolean} true if this queue contains the specified element,
+     * false otherwise.
+     */
+    contains(elem: T, equalsFunction?: util.IEqualsFunction<T>): boolean;
+    /**
+     * Checks if this queue is empty.
+     * @return {boolean} true if and only if this queue contains no items; false
+     * otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Removes all of the elements from this queue.
+     */
+    clear(): void;
+    /**
+     * Executes the provided function once for each element present in this queue in
+     * FIFO order.
+     * @param {function(Object):*} callback function to execute, it is
+     * invoked with one argument: the element value, to break the iteration you can
+     * optionally return false.
+     */
+    forEach(callback: util.ILoopFunction<T>): void;
+}

package/dist/utils/BSTree/index.d.ts

@@ -0,0 +1 @@
+export { default as BSTree } from './BSTree';

package/dist/utils/BSTree/utils.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Function signature for comparing
+ * <0 means a is smaller
+ * = 0 means they are equal
+ * >0 means a is larger
+ */
+export interface ICompareFunction<T> {
+    (a: T, b: T): number;
+}
+/**
+ * 相近元素比较函数
+ */
+export interface IClosestCompareFunction<T> {
+    (currentElement: T, targetElement: T, closestElement: T | null): boolean;
+}
+/**
+ * Function signature for checking equality
+ */
+export interface IEqualsFunction<T> {
+    (a: T, b: T): boolean;
+}
+/**
+ * Function signature for Iterations. Return false to break from loop
+ */
+export interface ILoopFunction<T> {
+    (a: T): boolean | void;
+}
+/**
+ * Default function to compare element order.
+ * @function
+ */
+export declare function defaultCompare<T>(a: T, b: T): number;
+/**
+ * Default function to test equality.
+ * @function
+ */
+export declare function defaultEquals<T>(a: T, b: T): boolean;
+/**
+ * Checks if the given argument is a function.
+ * @function
+ */
+export declare function isFunction(func: any): boolean;
+/**
+ * Checks if the given argument is undefined.
+ * @function
+ */
+export declare function isUndefined(obj: any): obj is undefined;

package/dist/utils/box.d.ts

@@ -0,0 +1,7 @@
+import type { Vector2Data } from 'modern-canvas';
+import type { AxisAlignedBoundingBox, OrientedBoundingBox } from '../types';
+export declare function boundingBoxToStyle(box: OrientedBoundingBox): Record<string, any>;
+export declare function isPointInsideAabb(point: Vector2Data, box: AxisAlignedBoundingBox): boolean;
+export declare function isOverlappingAabb(aabb1: AxisAlignedBoundingBox, aabb2: AxisAlignedBoundingBox, axis?: 'vertical' | 'horizontal'): boolean;
+export declare function isOverlappingObb(box1: OrientedBoundingBox, box2: OrientedBoundingBox): boolean;
+export declare function minBoundingBox(rects: OrientedBoundingBox[]): OrientedBoundingBox;

package/dist/utils/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SUPPORTS_CLIPBOARD: boolean;
+export declare const USER_AGENT: string;
+export declare const isMac: boolean;
+export declare const isWindows: boolean;

package/dist/utils/create.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedElement } from 'modern-idoc';
+export declare function createTextElement(content: string, style?: Record<string, any>): NormalizedElement;
+export declare function createImageElement(image: string): Promise<NormalizedElement>;

package/dist/utils/helper.d.ts

@@ -0,0 +1 @@
+export declare function isClickInsideElement(event: MouseEvent, targetDiv: HTMLElement): boolean;

package/dist/utils/image.d.ts

@@ -0,0 +1,26 @@
+interface ImgSize {
+    width: number;
+    height: number;
+}
+interface Options {
+    useCrossOrigin?: boolean;
+    timeout?: number;
+}
+export declare function getImageSizeFromUrl(url: string, opts?: Options): Promise<ImgSize>;
+export declare const imageMimeTypeExtMap: {
+    'image/jpeg': string[];
+    'image/png': string[];
+    'image/gif': string[];
+    'image/svg+xml': string[];
+    'image/tiff': string[];
+    'image/bmp': string[];
+    'image/x-ms-bmp': string[];
+    'image/vnd.microsoft.icon': string[];
+    'image/webp': string[];
+    'image/heif': string[];
+    'image/heic': string[];
+    'image/avif': string[];
+};
+export declare const imageExts: string[];
+export declare const imageExtRe: RegExp;
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './box';
+export * from './constants';
+export * from './create';
+export * from './helper';
+export * from './image';
+export * from './propsFactory';
+export * from './random';

package/dist/utils/propsFactory.d.ts

@@ -0,0 +1,57 @@
+import type { ComponentObjectPropsOptions, Prop, PropType } from 'vue';
+/**
+ * Creates a factory function for props definitions.
+ * This is used to define props in va composable then override
+ * default values in an implementing component.
+ *
+ * @example Simplified signature
+ * (props: Props) => (defaults?: Record<keyof props, any>) => Props
+ *
+ * @example Usage
+ * const makeProps = propsFactory({
+ *   foo: String,
+ * })
+ *
+ * defineComponent({
+ *   props: {
+ *     ...makeProps({
+ *       foo: 'a',
+ *     }),
+ *   },
+ *   setup (props) {
+ *     // would be "string | undefined", now "string" because a default has been provided
+ *     props.foo
+ *   },
+ * }
+ */
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults) => AppendDefault<PropsOptions, Defaults>;
+type AppendDefault<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {
+    [P in keyof T]-?: unknown extends D[P] ? T[P] : T[P] extends Record<string, unknown> ? Omit<T[P], 'type' | 'default'> & {
+        type: PropType<MergeTypeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    } : {
+        type: PropType<MergeTypeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    };
+};
+type MergeTypeDefault<T, D, P = InferPropType<T>> = unknown extends D ? P : (P | D);
+type MergeDefault<T, D, P = InferPropType<T>> = unknown extends D ? P : (NonNullable<P> | D);
+/**
+ * Like `Partial<T>` but doesn't care what the value is
+ */
+type PartialKeys<T> = {
+    [P in keyof T]?: unknown;
+};
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+    type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+    type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+    type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+    type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+export {};

package/dist/utils/random.d.ts

@@ -0,0 +1,3 @@
+export declare const getRandomValues: <T extends ArrayBufferView>(array: T) => T;
+export declare const uint32: () => number;
+export declare function uuidv4(): string;