suneditor 3.0.0-alpha.2 → 3.0.0-alpha.20

package/types/helper/env.d.ts

@@ -0,0 +1,149 @@
+/**
+ * @description Object.values
+ * @param {Object<*, *>} obj Object parameter.
+ * @returns {Array<*>}
+ */
+export function getValues(obj: any): Array<any>;
+/**
+ * @description Convert the CamelCase To the KebabCase.
+ * @param {string|Array<string>} param [Camel string]
+ */
+export function camelToKebabCase(param: string | Array<string>): any;
+/**
+ * @overload
+ * @param {string} param - Kebab-case string.
+ * @returns {string} CamelCase string.
+ */
+export function kebabToCamelCase(param: string): string;
+/**
+ * @overload
+ * @param {Array<string>} param - Array of Kebab-case strings.
+ * @returns {Array<string>} Array of CamelCase strings.
+ */
+export function kebabToCamelCase(param: Array<string>): Array<string>;
+/**
+ * @description Gets XMLHttpRequest object
+ * @returns {XMLHttpRequest}
+ */
+export function getXMLHttpRequest(): XMLHttpRequest;
+/**
+ * @deprecated
+ * @description Returns the CSS text that has been applied to the current page.
+ * @param {Document|null} doc To get the CSS text of an document. If null get the current document.
+ * @returns {string} Styles string
+ */
+export function getPageStyle(doc: Document | null): string;
+/**
+ * @deprecated
+ * @description Get the the tag path of the arguments value
+ * @param {Array<string>} nameArray File name array
+ * @param {string} extension js, css
+ * @returns {string} If not found, return the first found value
+ */
+export function getIncludePath(nameArray: Array<string>, extension: string): string;
+/** @type {Window} */
+export const _w: Window;
+/** @type {Document} */
+export const _d: Document;
+/**
+ * @description No event symbol
+ * @type {Symbol}
+ */
+export const NO_EVENT: symbol;
+/**
+ * @description On over component symbol
+ * @type {Symbol}
+ */
+export const ON_OVER_COMPONENT: symbol;
+/** --- Check browser --- */
+/**
+ * @description Check if support ResizeObserver function
+ * @returns {boolean} Whether support ResizeObserver function or not.
+ */
+export const isResizeObserverSupported: boolean;
+/**
+ * @description Check if User Agent is Edge
+ * @returns {boolean} Whether User Agent is Edge or not.
+ */
+export const isEdge: boolean;
+/**
+ * @description Check if User Agent is OSX or IOS
+ * @type {boolean}
+ */
+export const isOSX_IOS: boolean;
+/**
+ * @description Check if User Agent Blink engine.
+ * @type {boolean}
+ */
+export const isBlink: boolean;
+/**
+ * @description Check if User Agent is Firefox (Gecko).
+ * @type {boolean}
+ */
+export const isGecko: boolean;
+/**
+ * @description Check if User Agent is Chromium browser.
+ * @type {boolean}
+ */
+export const isChromium: boolean;
+/**
+ * @description Check if User Agent is Safari.
+ * @type {boolean}
+ */
+export const isSafari: boolean;
+/**
+ * @description Check if User Agent is Mobile device.
+ * - when the device is touchable, it is judged as a mobile device.
+ * @type {boolean}
+ */
+export const isMobile: boolean;
+/**
+ * @description Check if User Agent is Android mobile device.
+ * @type {boolean}
+ */
+export const isAndroid: boolean;
+/**
+ * @description Command(Mac) or CTRL(Window) icon.
+ * @type {string}
+ */
+export const cmdIcon: string;
+/**
+ * @description SHIFT(Mac, Window) icon.
+ * @type {string}
+ */
+export const shiftIcon: string;
+/**
+ * @description Device pixel ratio
+ * @type {number}
+ */
+export const DPI: number;
+/** --- editor env --- */
+export const KATEX_WEBSITE: 'https://katex.org/docs/supported.html';
+export const MATHJAX_WEBSITE: 'https://www.mathjax.org/';
+export default env;
+declare namespace env {
+	export { _w };
+	export { _d };
+	export { NO_EVENT };
+	export { ON_OVER_COMPONENT };
+	export { getValues };
+	export { camelToKebabCase };
+	export { kebabToCamelCase };
+	export { getXMLHttpRequest };
+	export { getPageStyle };
+	export { getIncludePath };
+	export { isResizeObserverSupported };
+	export { isEdge };
+	export { isBlink };
+	export { isGecko };
+	export { isChromium };
+	export { isSafari };
+	export { isOSX_IOS };
+	export { isAndroid };
+	export { isMobile };
+	export { cmdIcon };
+	export { shiftIcon };
+	export { DPI };
+	export { KATEX_WEBSITE };
+	export { MATHJAX_WEBSITE };
+}

package/types/helper/index.d.ts

@@ -0,0 +1,163 @@
+export const env: {
+	_w: Window;
+	_d: Document;
+	NO_EVENT: symbol;
+	ON_OVER_COMPONENT: symbol;
+	getValues: typeof import('./env').getValues;
+	camelToKebabCase: typeof import('./env').camelToKebabCase;
+	kebabToCamelCase: typeof import('./env').kebabToCamelCase;
+	getXMLHttpRequest: typeof import('./env').getXMLHttpRequest;
+	getPageStyle: typeof import('./env').getPageStyle;
+	getIncludePath: typeof import('./env').getIncludePath;
+	isResizeObserverSupported: boolean;
+	isEdge: boolean;
+	isBlink: boolean;
+	isGecko: boolean;
+	isChromium: boolean;
+	isSafari: boolean;
+	isOSX_IOS: boolean;
+	isAndroid: boolean;
+	isMobile: boolean;
+	cmdIcon: string;
+	shiftIcon: string;
+	DPI: number;
+	KATEX_WEBSITE: string;
+	MATHJAX_WEBSITE: string;
+};
+export const unicode: {
+	zeroWidthSpace: string;
+	zeroWidthRegExp: RegExp;
+	onlyZeroWidthRegExp: RegExp;
+	escapeStringRegexp: typeof import('./unicode').escapeStringRegexp;
+};
+export const converter: {
+	htmlToEntity: typeof import('./converter').htmlToEntity;
+	entityToHTML: typeof import('./converter').entityToHTML;
+	debounce: typeof import('./converter').debounce;
+	syncMaps: typeof import('./converter').syncMaps;
+	fontSize: typeof import('./converter').fontSize;
+	nodeListToArray: typeof import('./converter').nodeListToArray;
+	swapKeyValue: typeof import('./converter').swapKeyValue;
+	createElementWhitelist: typeof import('./converter').createElementWhitelist;
+	createElementBlacklist: typeof import('./converter').createElementBlacklist;
+	isHexColor: typeof import('./converter').isHexColor;
+	rgb2hex: typeof import('./converter').rgb2hex;
+	getWidthInPercentage: typeof import('./converter').getWidthInPercentage;
+	textToAnchor: typeof import('./converter').textToAnchor;
+	spanToStyleNode: typeof import('./converter').spanToStyleNode;
+	addUrlQuery: typeof import('./converter').addUrlQuery;
+	_setDefaultOptionStyle: typeof import('./converter')._setDefaultOptionStyle;
+	_setIframeStyleLinks: typeof import('./converter')._setIframeStyleLinks;
+	_setAutoHeightStyle: typeof import('./converter')._setAutoHeightStyle;
+};
+export const dom: {
+	query: {
+		getPositionIndex: typeof import('./dom/domQuery').getPositionIndex;
+		getNodePath: typeof import('./dom/domQuery').getNodePath;
+		getNodeFromPath: typeof import('./dom/domQuery').getNodeFromPath;
+		getListChildren: typeof import('./dom/domQuery').getListChildren;
+		getListChildNodes: typeof import('./dom/domQuery').getListChildNodes;
+		getNodeDepth: typeof import('./dom/domQuery').getNodeDepth;
+		sortNodeByDepth: typeof import('./dom/domQuery').sortNodeByDepth;
+		compareElements: typeof import('./dom/domQuery').compareElements;
+		getParentElement: typeof import('./dom/domQuery').getParentElement;
+		getParentElements: typeof import('./dom/domQuery').getParentElements;
+		getCommandTarget: typeof import('./dom/domQuery').getCommandTarget;
+		getEventTarget: typeof import('./dom/domQuery').getEventTarget;
+		getEdgeChild: typeof import('./dom/domQuery').getEdgeChild;
+		getEdgeChildNodes: typeof import('./dom/domQuery').getEdgeChildNodes;
+		getPreviousDeepestNode: typeof import('./dom/domQuery').getPreviousDeepestNode;
+		getNextDeepestNode: typeof import('./dom/domQuery').getNextDeepestNode;
+		findTextIndexOnLine: typeof import('./dom/domQuery').findTextIndexOnLine;
+		findTabEndIndex: typeof import('./dom/domQuery').findTabEndIndex;
+		getScrollParent: typeof import('./dom/domQuery').getScrollParent;
+		getIframeDocument: typeof import('./dom/domQuery').getIframeDocument;
+	};
+	check: {
+		isZeroWidth: typeof import('./dom/domCheck').isZeroWidth;
+		isEdgePoint: typeof import('./dom/domCheck').isEdgePoint;
+		isText: typeof import('./dom/domCheck').isText;
+		isElement: typeof import('./dom/domCheck').isElement;
+		isInputElement: typeof import('./dom/domCheck').isInputElement;
+		isButtonElement: typeof import('./dom/domCheck').isButtonElement;
+		isList: typeof import('./dom/domCheck').isList;
+		isListCell: typeof import('./dom/domCheck').isListCell;
+		isTable: typeof import('./dom/domCheck').isTable;
+		isTableElements: typeof import('./dom/domCheck').isTableElements;
+		isTableCell: typeof import('./dom/domCheck').isTableCell;
+		isTableRow: typeof import('./dom/domCheck').isTableRow;
+		isBreak: typeof import('./dom/domCheck').isBreak;
+		isAnchor: typeof import('./dom/domCheck').isAnchor;
+		isMedia: typeof import('./dom/domCheck').isMedia;
+		isIFrame: typeof import('./dom/domCheck').isIFrame;
+		isFigure: typeof import('./dom/domCheck').isFigure;
+		isEmptyLine: typeof import('./dom/domCheck').isEmptyLine;
+		isWysiwygFrame: typeof import('./dom/domCheck').isWysiwygFrame;
+		isNonEditable: typeof import('./dom/domCheck').isNonEditable;
+		isSpanWithoutAttr: typeof import('./dom/domCheck').isSpanWithoutAttr;
+		isSameAttributes: typeof import('./dom/domCheck').isSameAttributes;
+		isExcludeFormat: typeof import('./dom/domCheck').isExcludeFormat;
+		isUneditable: typeof import('./dom/domCheck').isUneditable;
+		isImportantDisabled: typeof import('./dom/domCheck').isImportantDisabled;
+	};
+	utils: {
+		clone: <T extends Node>(node: T, deep?: boolean) => T;
+		createElement: typeof import('./dom/domUtils').createElement;
+		createTextNode: typeof import('./dom/domUtils').createTextNode;
+		getAttributesToString: typeof import('./dom/domUtils').getAttributesToString;
+		arrayFilter: typeof import('./dom/domUtils').arrayFilter;
+		arrayFind: typeof import('./dom/domUtils').arrayFind;
+		arrayIncludes: typeof import('./dom/domUtils').arrayIncludes;
+		getArrayIndex: typeof import('./dom/domUtils').getArrayIndex;
+		nextIndex: typeof import('./dom/domUtils').nextIndex;
+		prevIndex: typeof import('./dom/domUtils').prevIndex;
+		copyTagAttributes: typeof import('./dom/domUtils').copyTagAttributes;
+		copyFormatAttributes: typeof import('./dom/domUtils').copyFormatAttributes;
+		removeItem: typeof import('./dom/domUtils').removeItem;
+		changeElement: typeof import('./dom/domUtils').changeElement;
+		changeTxt: typeof import('./dom/domUtils').changeTxt;
+		setStyle: typeof import('./dom/domUtils').setStyle;
+		setDisabled: typeof import('./dom/domUtils').setDisabled;
+		hasClass: typeof import('./dom/domUtils').hasClass;
+		addClass: typeof import('./dom/domUtils').addClass;
+		removeClass: typeof import('./dom/domUtils').removeClass;
+		toggleClass: typeof import('./dom/domUtils').toggleClass;
+		getClientSize: typeof import('./dom/domUtils').getClientSize;
+		getViewportSize: typeof import('./dom/domUtils').getViewportSize;
+		applyInlineStylesAll: typeof import('./dom/domUtils').applyInlineStylesAll;
+		waitForMediaLoad: (target: Node, timeout?: number) => Promise<void>;
+	};
+};
+export const numbers: {
+	is: typeof import('./numbers').is;
+	get: typeof import('./numbers').get;
+	getOverlapRangeAtIndex: typeof import('./numbers').getOverlapRangeAtIndex;
+	isEven: typeof import('./numbers').isEven;
+	isOdd: typeof import('./numbers').isOdd;
+};
+export const keyCodeMap: {
+	isShift: typeof import('./keyCodeMap').isShift;
+	isCtrl: typeof import('./keyCodeMap').isCtrl;
+	isAlt: typeof import('./keyCodeMap').isAlt;
+	isComposing: typeof import('./keyCodeMap').isComposing;
+	isBackspace: typeof import('./keyCodeMap').isBackspace;
+	isTab: typeof import('./keyCodeMap').isTab;
+	isEnter: typeof import('./keyCodeMap').isEnter;
+	isEsc: typeof import('./keyCodeMap').isEsc;
+	isSpace: typeof import('./keyCodeMap').isSpace;
+	isDirectionKey: typeof import('./keyCodeMap').isDirectionKey;
+	isRemoveKey: typeof import('./keyCodeMap').isRemoveKey;
+	isNonTextKey: typeof import('./keyCodeMap').isNonTextKey;
+	isHistoryIgnoreKey: typeof import('./keyCodeMap').isHistoryIgnoreKey;
+	isDocumentTypeObserverKey: typeof import('./keyCodeMap').isDocumentTypeObserverKey;
+	isNonResponseKey: typeof import('./keyCodeMap').isNonResponseKey;
+};
+declare namespace _default {
+	export { env };
+	export { unicode };
+	export { converter };
+	export { dom };
+	export { numbers };
+	export { keyCodeMap };
+}
+export default _default;

package/types/helper/keyCodeMap.d.ts

@@ -0,0 +1,110 @@
+/** ------------------------------------------------------- [meta] -------------------------------------------------------  */
+/**
+ * @description Shift check
+ * @param {KeyboardEvent} e Event object
+ * @returns {boolean}
+ */
+export function isShift(e: KeyboardEvent): boolean;
+/**
+ * @description [Ctrl|Meta] check
+ * @param {KeyboardEvent} e Event object
+ * @returns {boolean}
+ */
+export function isCtrl(e: KeyboardEvent): boolean;
+/**
+ * @description Alt check
+ * @param {KeyboardEvent} e Event object
+ * @returns {boolean}
+ */
+export function isAlt(e: KeyboardEvent): boolean;
+/**
+ * @description event.isComposing check
+ * @param {KeyboardEvent} e Event object
+ * @returns {boolean}
+ */
+export function isComposing(e: KeyboardEvent): boolean;
+/**
+ * @description Backspace key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isBackspace(code: string): boolean;
+/**
+ * @description Tab key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isTab(code: string): boolean;
+/**
+ * @description Enter key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isEnter(code: string): boolean;
+/**
+ * @description ESC key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isEsc(code: string): boolean;
+/**
+ * @description Space key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isSpace(code: string): boolean;
+/** ------------------------------------------------------- [key] -------------------------------------------------------  */
+/**
+ * @description Direction key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isDirectionKey(code: string): boolean;
+/**
+ * @description [delete, backspace] key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isRemoveKey(code: string): boolean;
+/**
+ * @description Non-text key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isNonTextKey(code: string): boolean;
+/**
+ * @description History ignore key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isHistoryIgnoreKey(code: string): boolean;
+/**
+ * @description Document type observer key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isDocumentTypeObserverKey(code: string): boolean;
+/**
+ * @description Non-response key check
+ * @param {string} code Event.code
+ * @returns {boolean}
+ */
+export function isNonResponseKey(code: string): boolean;
+export default keyCodeMap;
+declare namespace keyCodeMap {
+	export { isShift };
+	export { isCtrl };
+	export { isAlt };
+	export { isComposing };
+	export { isBackspace };
+	export { isTab };
+	export { isEnter };
+	export { isEsc };
+	export { isSpace };
+	export { isDirectionKey };
+	export { isRemoveKey };
+	export { isNonTextKey };
+	export { isHistoryIgnoreKey };
+	export { isDocumentTypeObserverKey };
+	export { isNonResponseKey };
+}

package/types/helper/numbers.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @description Checks for numeric (with decimal point).
+ * @param {*} text Text string or number
+ * @returns {boolean}
+ */
+export function is(text: any): boolean;
+/**
+ * @description Get a number.
+ * @param {string|number} value Text string or number
+ * @param {number} [maxDec=0] Maximum number of decimal places (-1 : Infinity)
+ * @returns {number}
+ */
+export function get(value: string | number, maxDec?: number): number;
+/**
+ * @description It compares the start and end indexes of 'a' and 'b' and returns the number of overlapping indexes in the range.
+ * - e.g.) 1, 5, 4, 6 => '2' (4,5)
+ * @param {number} aStart Start index of 'a'
+ * @param {number} aEnd End index of 'a'
+ * @param {number} bStart Start index of 'b'
+ * @param {number} bEnd Start index of 'b'
+ * @returns {number}
+ */
+export function getOverlapRangeAtIndex(aStart: number, aEnd: number, bStart: number, bEnd: number): number;
+/**
+ * @description Discriminate an even number
+ * @param {number} value number
+ * @returns {boolean}
+ */
+export function isEven(value: number): boolean;
+/**
+ * @description Discriminate an odd number
+ * @param {number} value number
+ * @returns {boolean}
+ */
+export function isOdd(value: number): boolean;
+export default numbers;
+declare namespace numbers {
+	export { is };
+	export { get };
+	export { getOverlapRangeAtIndex };
+	export { isEven };
+	export { isOdd };
+}

package/types/helper/unicode.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @description Escape a string for safe use in regular expressions.
+ * @param {string} string String to escape
+ * @returns {string}
+ */
+export function escapeStringRegexp(string: string): string;
+/**
+ * @description Unicode Character 'ZERO WIDTH SPACE' (\u200B)
+ * @type {string}
+ */
+export const zeroWidthSpace: string;
+/**
+ * @description Regular expression to find 'zero width space' (/\u200B/g)
+ * @type {RegExp}
+ */
+export const zeroWidthRegExp: RegExp;
+/**
+ * @description Regular expression to find only 'zero width space' (/\u200B/g)
+ * @type {RegExp}
+ */
+export const onlyZeroWidthRegExp: RegExp;
+export default unicode;
+declare namespace unicode {
+	export { zeroWidthSpace };
+	export { zeroWidthRegExp };
+	export { onlyZeroWidthRegExp };
+	export { escapeStringRegexp };
+}