jodit 4.0.0-beta.67 → 4.0.0-beta.69

package/esm/core/async/async.d.ts

@@ -0,0 +1,73 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * [[include:core/async/README.md]]
+ * @packageDocumentation
+ * @module async
+ */
+import type { CallbackFunction, IAsync, IAsyncParams, ITimeout, Nullable, RejectablePromise } from 'jodit/types';
+type Callback = (...args: any[]) => void;
+export declare class Async implements IAsync {
+    private timers;
+    private __callbacks;
+    delay(timeout: number | IAsyncParams): RejectablePromise<void>;
+    setTimeout(callback: Callback, timeout: number | IAsyncParams, ...args: any[]): number;
+    updateTimeout(label: string, timeout: number): Nullable<number>;
+    private clearLabel;
+    clearTimeout(timer: number): void;
+    clearTimeout(label: string): void;
+    /**
+     * Debouncing enforces that a function not be called again until a certain amount of time has passed without
+     * it being called. As in "execute this function only if 100 milliseconds have passed without it being called."
+     *
+     * @example
+     * ```javascript
+     * var jodit = Jodit.make('.editor');
+     * jodit.e.on('mousemove', jodit.async.debounce(() => {
+     * 	// Do expensive things
+     * }, 100));
+     * ```
+     */
+    debounce(fn: CallbackFunction, timeout: ITimeout | IAsyncParams, firstCallImmediately?: boolean): CallbackFunction;
+    private __queueMicrotaskNative;
+    microDebounce<T extends CallbackFunction>(fn: T, firstCallImmediately?: boolean): T;
+    /**
+     * Throttling enforces a maximum number of times a function can be called over time.
+     * As in "execute this function at most once every 100 milliseconds."
+     *
+     * @example
+     * ```javascript
+     * var jodit = Jodit.make('.editor');
+     * jodit.e.on(document.body, 'scroll', jodit.async.throttle(function() {
+     * 	// Do expensive things
+     * }, 100));
+     * ```
+     */
+    throttle(fn: CallbackFunction, timeout: ITimeout | IAsyncParams, ignore?: boolean): CallbackFunction;
+    private promisesRejections;
+    promise<T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): RejectablePromise<T>;
+    /**
+     * Get Promise status
+     */
+    promiseState(p: Promise<any>): Promise<'pending' | 'fulfilled' | 'rejected'>;
+    private requestsIdle;
+    private requestsRaf;
+    private requestIdleCallbackNative;
+    private cancelIdleCallbackNative;
+    requestIdleCallback(callback: IdleRequestCallback, options?: {
+        timeout: number;
+    }): number;
+    requestIdlePromise(options?: {
+        timeout: number;
+    }): RejectablePromise<number>;
+    cancelIdleCallback(request: number): void;
+    requestAnimationFrame(callback: FrameRequestCallback): number;
+    cancelAnimationFrame(request: number): void;
+    clear(): void;
+    isDestructed: boolean;
+    destruct(): any;
+}
+export {};

package/esm/core/async/async.js

@@ -3,14 +3,14 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
-import { setTimeout, clearTimeout } from 'jodit/core/helpers/async';
-import { isFunction } from 'jodit/core/helpers/checker/is-function';
-import { isPlainObject } from 'jodit/core/helpers/checker/is-plain-object';
-import { isPromise } from 'jodit/core/helpers/checker/is-promise';
-import { isString } from 'jodit/core/helpers/checker/is-string';
-import { isNumber } from 'jodit/core/helpers/checker/is-number';
-import { assert } from 'jodit/core/helpers/utils/assert';
-import { IS_ES_NEXT } from 'jodit/core/constants';
+import { setTimeout, clearTimeout } from "../helpers/async/index.js";
+import { isFunction } from "../helpers/checker/is-function.js";
+import { isPlainObject } from "../helpers/checker/is-plain-object.js";
+import { isPromise } from "../helpers/checker/is-promise.js";
+import { isString } from "../helpers/checker/is-string.js";
+import { isNumber } from "../helpers/checker/is-number.js";
+import { assert } from "../helpers/utils/assert.js";
+import { IS_ES_NEXT } from "../constants.js";
 export class Async {
     constructor() {
         this.timers = new Map();

package/esm/core/async/index.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module async
+ */
+export * from './async';

package/esm/core/async/index.js

@@ -6,4 +6,4 @@
 /**
  * @module async
  */
-export * from './async';
+export * from "./async.js";

package/esm/core/component/component.d.ts

@@ -0,0 +1,121 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * [[include:core/component/README.md]]
+ * @packageDocumentation
+ * @module component
+ */
+import type { ComponentStatus, IAsync, IComponent, IDictionary, Nullable } from 'jodit/types';
+/**
+ * The base class of all Jodit UI components. Provides work with a life cycle.
+ */
+export declare abstract class Component implements IComponent {
+    static STATUSES: {
+        readonly beforeInit: "beforeInit";
+        readonly ready: "ready";
+        readonly beforeDestruct: "beforeDestruct";
+        readonly destructed: "destructed";
+    };
+    private __componentName;
+    async: IAsync;
+    get componentName(): string;
+    readonly uid: string;
+    /**
+     * Calc BEM element class name
+     * @param elementName - element name in the bem classification
+     */
+    getFullElName(elementName: string): string;
+    getFullElName(elementName: string, mod: string): string;
+    getFullElName(elementName: string, mod: string, modValue: boolean | string): string;
+    /**
+     * The document in which jodit was created
+     */
+    get ownerDocument(): Document;
+    /**
+     * Shortcut for `this.ownerDocument`
+     */
+    get od(): Document;
+    /**
+     * The window in which jodit was created
+     */
+    ownerWindow: Window;
+    get ow(): Window;
+    /**
+     * Safe get any field
+     * @example
+     * ```js
+     * private a = {
+     * 	b: {
+     * 		c: {
+     * 			e: {
+     * 				g: {
+     * 					color: 'red'
+     * 				}
+     * 			}
+     * 		}
+     * 	}
+     * }
+     *
+     * this.get('a.b.c.e.g.color'); // Safe access to color
+     * // instead using optionsl chaining
+     * this?.a?.b?.c?.e?.g?.color
+     * ```
+     *
+     * @param chain - the path to be traversed in the obj object
+     * @param obj - the object in which the value is searched
+     */
+    get<T>(chain: string, obj?: IDictionary): Nullable<T>;
+    /**
+     * Component is ready for work
+     */
+    get isReady(): boolean;
+    /**
+     * Component was destructed
+     */
+    get isDestructed(): boolean;
+    /**
+     * The component is currently undergoing destructuring or has already been destroyed.
+     * Those. you should not hang new events on him now or do anything else with him.
+     */
+    get isInDestruct(): boolean;
+    /**
+     * Bind destructor to some View
+     */
+    bindDestruct(component: IComponent): this;
+    abstract className(): string;
+    protected constructor();
+    /**
+     * Destruct component method
+     */
+    destruct(): void;
+    private __componentStatus;
+    /**
+     * Current component status
+     */
+    get componentStatus(): ComponentStatus;
+    /**
+     * Setter for current component status
+     */
+    set componentStatus(componentStatus: ComponentStatus);
+    /**
+     * Set component status
+     * @param componentStatus - component status
+     * @see ComponentStatus
+     */
+    setStatus(componentStatus: ComponentStatus): void;
+    /**
+     * Set status recursively on all parents
+     */
+    private setStatusComponent;
+    /**
+     * Adds a handler for changing the component's status
+     *
+     * @param status - the status at which the callback is triggered
+     * @param callback - a function that will be called when the status is `status`
+     */
+    hookStatus(status: ComponentStatus, callback: (component: this) => void): void;
+    static isInstanceOf<T extends IComponent>(c: unknown | IComponent, constructorFunc: Function): c is T;
+}

package/esm/core/component/component.js

@@ -3,10 +3,10 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
-import { kebabCase, get, getClassName, isFunction, isVoid } from 'jodit/core/helpers';
-import { uniqueUid } from 'jodit/core/global';
-import { STATUSES } from 'jodit/core/component/statuses';
-import { Async } from 'jodit/core/async';
+import { kebabCase, get, getClassName, isFunction, isVoid } from "../helpers/index.js";
+import { uniqueUid } from "../global.js";
+import { STATUSES } from "./statuses.js";
+import { Async } from "../async/index.js";
 const StatusListHandlers = new Map();
 /**
  * The base class of all Jodit UI components. Provides work with a life cycle.

package/esm/core/component/index.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module component
+ */
+export * from './statuses';
+export * from './component';
+export * from './view-component';

package/esm/core/component/index.js

@@ -6,6 +6,6 @@
 /**
  * @module component
  */
-export * from './statuses';
-export * from './component';
-export * from './view-component';
+export * from "./statuses.js";
+export * from "./component.js";
+export * from "./view-component.js";

package/esm/core/component/statuses.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module component
+ */
+export declare const STATUSES: {
+    readonly beforeInit: "beforeInit";
+    readonly ready: "ready";
+    readonly beforeDestruct: "beforeDestruct";
+    readonly destructed: "destructed";
+};

package/esm/core/component/view-component.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module component
+ */
+import type { IViewBased, IViewComponent } from 'jodit/types';
+import { Component } from './component';
+export declare abstract class ViewComponent<T extends IViewBased = IViewBased> extends Component implements IViewComponent<T> {
+    /**
+     * Parent View element
+     */
+    jodit: T;
+    /**
+     * Shortcut for `this.jodit`
+     */
+    get j(): T;
+    get defaultTimeout(): number;
+    i18n(text: string, ...params: Array<string | number>): string;
+    /**
+     * Attach component to View
+     */
+    setParentView(jodit: T): this;
+    constructor(jodit: T);
+    /** @override */
+    destruct(): any;
+}

package/esm/core/component/view-component.js

@@ -3,7 +3,7 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
-import { Component } from './component';
+import { Component } from "./component.js";
 export class ViewComponent extends Component {
     /**
      * Shortcut for `this.jodit`

package/esm/core/constants.d.ts

@@ -0,0 +1,128 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module constants
+ */
+import type { HTMLTagNames, IDictionary } from 'jodit/types';
+export declare const APP_VERSION: string;
+export declare const ES: 'es5' | 'es2015' | 'es2018' | 'es2021';
+export declare const IS_ES_MODERN: boolean;
+export declare const IS_ES_NEXT: boolean;
+export declare const IS_PROD: boolean;
+export declare let IS_TEST: boolean;
+export declare const FAT_MODE: boolean;
+export declare const HOMEPAGE: string;
+export declare const SET_TEST: () => boolean;
+export declare const INVISIBLE_SPACE = "\uFEFF";
+export declare const NBSP_SPACE = "\u00A0";
+export declare const INVISIBLE_SPACE_REG_EXP: () => RegExp;
+export declare const INVISIBLE_SPACE_REG_EXP_END: () => RegExp;
+export declare const INVISIBLE_SPACE_REG_EXP_START: () => RegExp;
+export declare const SPACE_REG_EXP: () => RegExp;
+export declare const SPACE_REG_EXP_START: () => RegExp;
+export declare const SPACE_REG_EXP_END: () => RegExp;
+export declare const IS_BLOCK: RegExp;
+export declare const IS_INLINE: RegExp;
+export declare const LIST_TAGS: Set<"ol" | "ul">;
+export declare const INSEPARABLE_TAGS: Set<HTMLTagNames>;
+export declare const NO_EMPTY_TAGS: Set<HTMLTagNames>;
+export declare const KEY_META = "Meta";
+export declare const KEY_BACKSPACE = "Backspace";
+export declare const KEY_TAB = "Tab";
+export declare const KEY_ENTER = "Enter";
+export declare const KEY_ESC = "Escape";
+export declare const KEY_ALT = "Alt";
+export declare const KEY_LEFT = "ArrowLeft";
+export declare const KEY_UP = "ArrowUp";
+export declare const KEY_RIGHT = "ArrowRight";
+export declare const KEY_DOWN = "ArrowDown";
+export declare const KEY_SPACE = "Space";
+export declare const KEY_DELETE = "Delete";
+export declare const KEY_F3 = "F3";
+export declare const NEARBY = 5;
+export declare const ACCURACY = 10;
+export declare const COMMAND_KEYS: string[];
+export declare const BR = "br";
+export declare const PARAGRAPH = "p";
+/**
+ * WYSIWYG editor mode
+ */
+export declare const MODE_WYSIWYG = 1;
+/**
+ * html editor mode
+ */
+export declare const MODE_SOURCE = 2;
+/**
+ * Source code editor and HTML editor both like
+ * @see http://getuikit.com/docs/htmleditor.html|this
+ */
+export declare const MODE_SPLIT = 3;
+/**
+ * Is Internet Explorer
+ */
+export declare const IS_IE: boolean;
+/**
+ * For IE11 it will be 'text'. Need for dataTransfer.setData
+ */
+export declare const TEXT_PLAIN: string;
+export declare const TEXT_HTML: string;
+export declare const TEXT_RTF: string;
+export declare const MARKER_CLASS = "jodit-selection_marker";
+export declare const EMULATE_DBLCLICK_TIMEOUT = 300;
+/**
+ * Paste the copied text as HTML, all content will be pasted exactly as it was on the clipboard.
+ * So how would you copy its code directly into the source document.
+ * ```
+ * <h1 style="color:red">test</h1>
+ * ```
+ * Will be inserted into the document as
+ * ```
+ * <h1 style="color:red">test</h1>
+ * ```
+ */
+export declare const INSERT_AS_HTML = "insert_as_html";
+/**
+ * Same as [[INSERT_AS_HTML]], but content will be stripped of extra styles and empty tags
+ * ```html
+ * <h1 style="color:red">test</h1>
+ * ```
+ * Will be inserted into the document as
+ * ```html
+ * <h1>test</h1>
+ * ```
+ */
+export declare const INSERT_CLEAR_HTML = "insert_clear_html";
+/**
+ * The contents of the clipboard will be pasted into the document as plain text, i.e. all tags will be displayed as text.
+ * ```html
+ * <h1>test</h1>
+ * ```
+ * Will be inserted into the document as
+ * ```html
+ * &gt;&lt;h1&gt;test&lt;/h1&gt;
+ * ```
+ */
+export declare const INSERT_AS_TEXT = "insert_as_text";
+/**
+ * All tags will be stripped:
+ * ```html
+ * <h1>test</h1>
+ * ```
+ * Will be inserted into the document as
+ * ```html
+ * test
+ * ```
+ */
+export declare const INSERT_ONLY_TEXT = "insert_only_text";
+export declare const SAFE_COUNT_CHANGE_CALL = 10;
+export declare const IS_MAC: boolean;
+export declare const KEY_ALIASES: IDictionary<string>;
+export declare const BASE_PATH: string;
+export declare const TEMP_ATTR = "data-jodit-temp";
+export declare const lang: IDictionary<IDictionary<string>>;
+export declare const CLIPBOARD_ID = "clipboard";
+export declare const SOURCE_CONSUMER = "source-consumer";
+export declare const PASSIVE_EVENTS: Set<string>;

package/esm/core/constants.js

@@ -3,15 +3,15 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
-export const APP_VERSION = process.env.APP_VERSION;
+export const APP_VERSION = "4.0.0-beta.69";
 // eslint-disable-next-line prettier/prettier
-export const ES = process.env.TARGET_ES;
-export const IS_ES_MODERN = process.env.IS_ES_MODERN;
-export const IS_ES_NEXT = process.env.IS_ES_NEXT;
-export const IS_PROD = process.env.IS_PROD;
-export let IS_TEST = process.env.IS_TEST;
-export const FAT_MODE = process.env.FAT_MODE;
-export const HOMEPAGE = process.env.HOMEPAGE;
+export const ES = "es2020";
+export const IS_ES_MODERN = true;
+export const IS_ES_NEXT = true;
+export const IS_PROD = true;
+export let IS_TEST = false;
+export const FAT_MODE = false;
+export const HOMEPAGE = "https://xdsoft.net/jodit/";
 export const SET_TEST = () => (IS_TEST = true);
 export const INVISIBLE_SPACE = '\uFEFF';
 export const NBSP_SPACE = '\u00A0';

package/esm/core/create/create.d.ts

@@ -0,0 +1,58 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * [[include:core/create/README.md]]
+ * @packageDocumentation
+ * @module create
+ */
+import type { IDictionary, Attributes, Children, ICreate, CanUndef, NodeFunction } from 'jodit/types';
+export declare class Create implements ICreate {
+    readonly document: Document | (() => Document);
+    readonly createAttributes?: CanUndef<IDictionary<Attributes | NodeFunction>>;
+    private get doc();
+    constructor(document: Document | (() => Document), createAttributes?: CanUndef<IDictionary<Attributes | NodeFunction>>);
+    element<K extends keyof HTMLElementTagNameMap>(tagName: K, children?: Children): HTMLElementTagNameMap[K];
+    element<K extends keyof HTMLElementTagNameMap>(tagName: K, attributes?: Attributes, children?: Children): HTMLElementTagNameMap[K];
+    div(className?: string, childrenOrAttributes?: Children): HTMLDivElement;
+    div(className?: string, childrenOrAttributes?: Attributes, children?: Children): HTMLDivElement;
+    sandbox(): [HTMLElement, HTMLIFrameElement];
+    span(className?: string, childrenOrAttributes?: Children): HTMLSpanElement;
+    span(className?: string, childrenOrAttributes?: Attributes, children?: Children): HTMLSpanElement;
+    a(className?: string, children?: Children): HTMLAnchorElement;
+    a(className?: string, childrenOrAttributes?: Attributes, children?: Children): HTMLAnchorElement;
+    /**
+     * Create text node
+     */
+    text(value: string): Text;
+    /**
+     * Create invisible text node
+     */
+    fake(): Text;
+    /**
+     * Create HTML Document fragment element
+     */
+    fragment(): DocumentFragment;
+    /**
+     * Create DOM element from HTML text
+     *
+     * @param refsToggleElement - State dictionary in which you can set the visibility of some of the elements
+     * ```js
+     * const editor = Jodit.make('#editor');
+     * editor.createInside.fromHTML(`<div>
+     *   <input name="name" ref="name"/>
+     *   <input name="email" ref="email"/>
+     * </div>`, {
+     *   name: true,
+     *   email: false
+     * });
+     * ```
+     */
+    fromHTML(html: string | number, refsToggleElement?: IDictionary<boolean | void>): HTMLElement;
+    /**
+     * Apply to element `createAttributes` options
+     */
+    applyCreateAttributes(elm: HTMLElement): void;
+}

package/esm/core/create/create.js

@@ -3,10 +3,10 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
-import { isPlainObject, asArray, isFunction, refs, isString, attr } from 'jodit/core/helpers';
-import { assert } from 'jodit/core/helpers/utils/assert';
-import { Dom } from 'jodit/core/dom/dom';
-import { INVISIBLE_SPACE } from 'jodit/core/constants';
+import { isPlainObject, asArray, isFunction, refs, isString, attr } from "../helpers/index.js";
+import { assert } from "../helpers/utils/assert.js";
+import { Dom } from "../dom/dom.js";
+import { INVISIBLE_SPACE } from "../constants.js";
 export class Create {
     get doc() {
         // @ts-ignore - TODO it's a function

package/esm/core/create/index.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * @module create
+ */
+export * from './create';

package/esm/core/create/index.js

@@ -6,4 +6,4 @@
 /**
  * @module create
  */
-export * from './create';
+export * from "./create.js";

package/esm/core/decorators/cache/cache.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * [[include:core/decorators/cache/README.md]]
+ * @packageDocumentation
+ * @module decorators/cache
+ */
+import type { IDictionary } from 'jodit/types';
+export interface CachePropertyDescriptor<T, R> extends PropertyDescriptor {
+    get?: (this: T) => R;
+}
+export declare function cache<T, R>(target: object, name: PropertyKey, descriptor: CachePropertyDescriptor<T, R>): void;
+export declare function cacheHTML<T extends Function, R>(target: IDictionary, name: string, descriptor: CachePropertyDescriptor<T, R>): void;

package/esm/core/decorators/cache/cache.js

@@ -3,10 +3,10 @@
  * Released under MIT see LICENSE.txt in the project root for license information.
  * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
  */
-import { isFunction, isViewObject } from 'jodit/core/helpers/checker';
-import { error } from 'jodit/core/helpers/utils/error/error';
-import { Dom } from 'jodit/core/dom/dom';
-import { STATUSES } from 'jodit/core/component/statuses';
+import { isFunction, isViewObject } from "../../helpers/checker/index.js";
+import { error } from "../../helpers/utils/error/error.js";
+import { Dom } from "../../dom/dom.js";
+import { STATUSES } from "../../component/statuses.js";
 export function cache(target, name, descriptor) {
     const getter = descriptor.get;
     if (!getter) {

package/esm/core/decorators/component/component.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * [[include:core/decorators/component/README.md]]
+ * @packageDocumentation
+ * @module decorators/component
+ */
+interface ComponentCompatible {
+    new (...constructorArgs: any[]): any;
+}
+/**
+ * Decorate components and set status isReady after constructor
+ * @param constructorFunction - Component constructor class
+ */
+export declare function component<T extends ComponentCompatible>(constructorFunction: T): T;
+export {};

package/esm/core/decorators/debounce/debounce.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Jodit Editor (https://xdsoft.net/jodit/)
+ * Released under MIT see LICENSE.txt in the project root for license information.
+ * Copyright (c) 2013-2023 Valeriy Chupurnov. All rights reserved. https://xdsoft.net
+ */
+/**
+ * [[include:core/decorators/debounce/README.md]]
+ * @packageDocumentation
+ * @module decorators/debounce
+ */
+import type { IViewComponent, IAsyncParams, DecoratorHandler } from 'jodit/types';
+export declare function debounce<V extends IViewComponent = IViewComponent>(timeout?: number | ((ctx: V) => number | IAsyncParams) | IAsyncParams, firstCallImmediately?: boolean, method?: 'debounce' | 'throttle'): DecoratorHandler;
+/**
+ * Wrap function in throttle wrapper
+ */
+export declare function throttle<V extends IViewComponent = IViewComponent>(timeout?: number | ((ctx: V) => number | IAsyncParams) | IAsyncParams, firstCallImmediately?: boolean): DecoratorHandler;