@plohoj/html-editor 0.0.7 → 0.1.0

package/src/utils/compose-restore-history.ts

@@ -1,61 +1,61 @@
-import { merge, MonoTypeOperatorFunction, ReplaySubject } from 'rxjs';
-import { IRestoredHistoryOption, restoreHistory } from '../operators/restore-history';
-
-export type ComposedRestoredHistoryOptionList<T extends IRestoredHistoryOption = IRestoredHistoryOption> = readonly T[] | Record<string, T>;
-
-export type ComposedRestoredHistoryOperatorsRecord<T extends Record<string, IRestoredHistoryOption>> = {
-    [P in keyof T]: T[P] extends IRestoredHistoryOption<infer Input>
-        ? MonoTypeOperatorFunction<Input>
-        : never;
-}
-
-export type ComposedRestoredHistoryOperatorsArray<T extends readonly IRestoredHistoryOption[]> = {
-    [P in keyof T]: T[P] extends IRestoredHistoryOption<infer Input>
-        ? MonoTypeOperatorFunction<Input>
-        : never;
-}
-
-export type ComposedRestoredHistoryOperatorsList<T extends ComposedRestoredHistoryOptionList>
-    = T extends Array<any>
-        ? ComposedRestoredHistoryOperatorsArray<T>
-        : T extends Record<string, any>
-            ? ComposedRestoredHistoryOperatorsRecord<T>
-            : never;
-
-export interface IComposedRestoredHistory<T extends ComposedRestoredHistoryOptionList> {
-    operators: ComposedRestoredHistoryOperatorsList<T>;
-    cancelAll: () => void;
-}
-
-export function composeRestoreHistory<T extends ComposedRestoredHistoryOptionList>(
-    options: T,
-): IComposedRestoredHistory<T> {
-    const cancelSubject$ = new ReplaySubject<void>(1);
-    function cancelAll(): void {
-        cancelSubject$.next();
-    }
-    function convertOption(option: IRestoredHistoryOption): MonoTypeOperatorFunction<unknown> {
-        return restoreHistory({
-            ...option,
-            cancelRestore: !!option.cancelRestore
-                ? () => merge(
-                    cancelSubject$,
-                    option.cancelRestore!(),
-                )
-                : () => cancelSubject$,
-        });
-    }
-    let operators: ComposedRestoredHistoryOperatorsList<T>;
-    if (options instanceof Array) {
-        operators = options.map(convertOption) as readonly MonoTypeOperatorFunction<any>[] as ComposedRestoredHistoryOperatorsList<T>;
-    } else {
-        operators = {} as Record<string, MonoTypeOperatorFunction<any>> as ComposedRestoredHistoryOperatorsList<T>;
-        for (const key of Object.keys(options)) {
-            (operators as Record<string, MonoTypeOperatorFunction<any>>)[key] = convertOption(options[key]);
-        }        
-    }
-    return {
-        operators: operators as ComposedRestoredHistoryOperatorsList<T>,
-        cancelAll,
-    };
-}
+import { merge, MonoTypeOperatorFunction, ReplaySubject } from 'rxjs';
+import { IRestoredHistoryOption, restoreHistory } from '../operators/restore-history';
+
+export type ComposedRestoredHistoryOptionList<T extends IRestoredHistoryOption = IRestoredHistoryOption> = readonly T[] | Record<string, T>;
+
+export type ComposedRestoredHistoryOperatorsRecord<T extends Record<string, IRestoredHistoryOption>> = {
+    [P in keyof T]: T[P] extends IRestoredHistoryOption<infer Input>
+        ? MonoTypeOperatorFunction<Input>
+        : never;
+}
+
+export type ComposedRestoredHistoryOperatorsArray<T extends readonly IRestoredHistoryOption[]> = {
+    [P in keyof T]: T[P] extends IRestoredHistoryOption<infer Input>
+        ? MonoTypeOperatorFunction<Input>
+        : never;
+}
+
+export type ComposedRestoredHistoryOperatorsList<T extends ComposedRestoredHistoryOptionList>
+    = T extends Array<any>
+        ? ComposedRestoredHistoryOperatorsArray<T>
+        : T extends Record<string, any>
+            ? ComposedRestoredHistoryOperatorsRecord<T>
+            : never;
+
+export interface IComposedRestoredHistory<T extends ComposedRestoredHistoryOptionList> {
+    operators: ComposedRestoredHistoryOperatorsList<T>;
+    cancelAll: () => void;
+}
+
+export function composeRestoreHistory<T extends ComposedRestoredHistoryOptionList>(
+    options: T,
+): IComposedRestoredHistory<T> {
+    const cancelSubject$ = new ReplaySubject<void>(1);
+    function cancelAll(): void {
+        cancelSubject$.next();
+    }
+    function convertOption(option: IRestoredHistoryOption): MonoTypeOperatorFunction<unknown> {
+        return restoreHistory({
+            ...option,
+            cancelRestore: !!option.cancelRestore
+                ? () => merge(
+                    cancelSubject$,
+                    option.cancelRestore!(),
+                )
+                : () => cancelSubject$,
+        });
+    }
+    let operators: ComposedRestoredHistoryOperatorsList<T>;
+    if (options instanceof Array) {
+        operators = options.map(convertOption) as readonly MonoTypeOperatorFunction<any>[] as ComposedRestoredHistoryOperatorsList<T>;
+    } else {
+        operators = {} as Record<string, MonoTypeOperatorFunction<any>> as ComposedRestoredHistoryOperatorsList<T>;
+        for (const key of Object.keys(options)) {
+            (operators as Record<string, MonoTypeOperatorFunction<any>>)[key] = convertOption(options[key]);
+        }        
+    }
+    return {
+        operators: operators as ComposedRestoredHistoryOperatorsList<T>,
+        cancelAll,
+    };
+}

package/src/utils/find-recursively.ts

@@ -1,203 +1,203 @@
-import { falseStub, trueStub } from './stubs';
-
-export interface IFindRecursivelyMatherOptions {
-    field?: unknown;
-    value: unknown;
-    path: string;
-    depth: number;
-}
-
-export type FindRecursivelyMatcher = (options: Readonly<IFindRecursivelyMatherOptions>) => boolean;
-export type FindRecursivelyContinue = (result: Readonly<FindRecursivelyResult>) => boolean;
-export type FindRecursivelyResult = Record<string, unknown> | null;
-
-export interface IFindRecursivelyOptions {
-    /**
-     * Checking a field for compliance with conditions  
-     * If the method returns `true`, then the field will be added to the result list
-     */
-    matcher?: FindRecursivelyMatcher;
-    /**
-     * Filtering out the need for recursive field validation.
-     * * If the method returns `true`, then all child fields will be checked recursively.
-     * * If the method returns `false`, then the field is excluded from recursive validation.
-     */
-    filter?: FindRecursivelyMatcher;
-    /**
-     * Checking whether to continue searching. This check occurs after each new found field.
-     * * If the method returns `true`, then the recursive search terminates immediately.
-     * * If the method returns `false`, then the recursive search will continue.
-     */
-    stop?: FindRecursivelyContinue;
-    /** Regular expression to match with a constructed path */
-    pathRegExp?: RegExp;
-    /** Regular expression to match with a constructed path */
-    fieldRegExp?: RegExp;
-    /** Maximum depth of recursive search */
-    maxDepth?: number;
-    //** Minimum depth of recursive search */
-    minDepth?: number;
-    /**
-     * Checking getter fields
-     * * If the value is `true`, then the field getter will not be called to get the result.
-     * Accordingly, the result of the getter will not be checked.
-     * * If the value is `false`, then the field getter will be called to get the result.
-     * Getter result will be checked
-     */
-    isIgnoreGetters?: boolean;
-    /**
-     * Error handling when getting a result from a getter method.
-     * * If the method returns `true`, then the recursive search will continue.
-     * * If the method returns `false`, then the recursive search terminates immediately.
-     */
-    continueAfterGetterError?: (error: unknown) => boolean;
-}
-
-
-
-/** Recursive search on entity fields */
-export function findRecursively(obj: unknown, options: IFindRecursivelyOptions = {}): FindRecursivelyResult {
-    /** {value: path[]} */
-    const seen = new Map<unknown, Array<string>>();
-    const searched: Record<string, unknown> = {};
-    const needSeen = new Set<IFindRecursivelyMatherOptions>([{
-        value: obj,
-        depth: 0,
-        path: '',
-    }]);
-    const {
-        matcher = falseStub,
-        filter = trueStub,
-        continueAfterGetterError = trueStub,
-        stop = falseStub,
-        minDepth = 1,
-        maxDepth = Infinity,
-    } = options;
-    const pathRegExpCheck =  options.pathRegExp
-        ? (path?: string) => path ? options.pathRegExp?.test(path) : false
-        : falseStub;
-    const fieldRegExpCheck =  options.fieldRegExp
-        ? (field?: unknown) => typeof field === 'string' ? options.fieldRegExp?.test(field) : false
-        : falseStub;
-    let needStop: boolean = false;
-
-    function checkForNeedSeen(options: IFindRecursivelyMatherOptions) {
-        if (options.depth > maxDepth) {
-            return;
-        }
-        const isPrimitiveOrFunction = options.value === null || typeof options.value !== 'object';
-        if (!isPrimitiveOrFunction) {
-            const seenPathsForValue: Array<string> | undefined = seen.get(options.value);
-            if (seenPathsForValue) {
-                // TODO windows or document
-                // TODO List of visited objects, but with the wrong path
-                const hasCircularPath = seenPathsForValue.some(path => options.path.includes(path));
-                if (hasCircularPath) {
-                    return;
-                }
-            }
-            if (filter(options)) {
-                needSeen.add(options);
-                if (seenPathsForValue) {
-                    seenPathsForValue.push(options.path);
-                } else {
-                    seen.set(options.value, [options.path]);
-                }
-            }
-        }
-        if (options.depth < minDepth) {
-            return;
-        }
-        if (matcher(options) || pathRegExpCheck(options.path) || fieldRegExpCheck(options.field)) {
-            searched[options.path || '{}'] = options.value;
-            if (stop(searched)) {
-                needStop = true;
-            }
-        }
-    }
-
-    function iterateArrayLike(
-        iterator: IterableIterator<[unknown, unknown]>,
-        pathBuilder: (fieldIndex: unknown) => string,
-        incrementalDepth: number,
-    ): void {
-        for (const [fieldIndex, fieldValue] of iterator) {
-            checkForNeedSeen({
-                field: fieldIndex,
-                value: fieldValue,
-                path: pathBuilder(fieldIndex),
-                depth: incrementalDepth,
-            });
-            if (needStop) {
-                return;
-            }
-        }
-    }
-
-    while (!needStop) {
-        const iterator = needSeen.values().next();
-        if (iterator.done) {
-            break;
-        }
-        const {value, path, depth} = iterator.value;
-        const incrementalDepth = depth + 1;
-        needSeen.delete(iterator.value);
-
-        if (value instanceof Array) {
-            iterateArrayLike(
-                (value as unknown[]).entries(),
-                (fieldIndex) => `${path}[${fieldIndex}]`,
-                incrementalDepth,
-            );
-        } else if (value instanceof Map) {
-            iterateArrayLike(
-                (value as Map<unknown, unknown>).entries(),
-                (fieldIndex) => `${path}{${fieldIndex}}`,
-                incrementalDepth,
-            );
-        } else if (value instanceof Set) {
-            for (const [fieldIndex, fieldValue] of ([...value] as unknown[]).entries()) {
-                checkForNeedSeen({
-                    field: fieldValue,
-                    value: fieldValue,
-                    path: `${path || ''}<${fieldIndex}>`,
-                    depth: incrementalDepth,
-                });
-                if (needStop) {
-                    break;
-                }
-            }
-        } else if (typeof value === "object") {
-            for (const key of Object.keys(value as object)) {
-                let fieldValue: unknown;
-                if (Object.getOwnPropertyDescriptor(value, key)?.get && options.isIgnoreGetters) {
-                    continue;
-                }
-                try {
-                    fieldValue = (value as any)[key];
-                } catch (error: unknown) {
-                    if (!continueAfterGetterError(error)) {
-                        needStop = true;
-                        break;
-                    }
-                    fieldValue = error;
-                }
-
-                checkForNeedSeen({
-                    field: key,
-                    value: fieldValue,
-                    path: path ? `${path}.${key}` : key,
-                    depth: incrementalDepth
-                });
-                if (needStop) {
-                    break;
-                }
-            }
-        }
-    }
-
-    if (Object.keys(searched).length === 0) {
-        return null;
-    }
-    return searched;
-}
+import { falseStub, trueStub } from './stubs';
+
+export interface IFindRecursivelyMatherOptions {
+    field?: unknown;
+    value: unknown;
+    path: string;
+    depth: number;
+}
+
+export type FindRecursivelyMatcher = (options: Readonly<IFindRecursivelyMatherOptions>) => boolean;
+export type FindRecursivelyContinue = (result: Readonly<FindRecursivelyResult>) => boolean;
+export type FindRecursivelyResult = Record<string, unknown> | null;
+
+export interface IFindRecursivelyOptions {
+    /**
+     * Checking a field for compliance with conditions  
+     * If the method returns `true`, then the field will be added to the result list
+     */
+    matcher?: FindRecursivelyMatcher;
+    /**
+     * Filtering out the need for recursive field validation.
+     * * If the method returns `true`, then all child fields will be checked recursively.
+     * * If the method returns `false`, then the field is excluded from recursive validation.
+     */
+    filter?: FindRecursivelyMatcher;
+    /**
+     * Checking whether to continue searching. This check occurs after each new found field.
+     * * If the method returns `true`, then the recursive search terminates immediately.
+     * * If the method returns `false`, then the recursive search will continue.
+     */
+    stop?: FindRecursivelyContinue;
+    /** Regular expression to match with a constructed path */
+    pathRegExp?: RegExp;
+    /** Regular expression to match with a constructed path */
+    fieldRegExp?: RegExp;
+    /** Maximum depth of recursive search */
+    maxDepth?: number;
+    //** Minimum depth of recursive search */
+    minDepth?: number;
+    /**
+     * Checking getter fields
+     * * If the value is `true`, then the field getter will not be called to get the result.
+     * Accordingly, the result of the getter will not be checked.
+     * * If the value is `false`, then the field getter will be called to get the result.
+     * Getter result will be checked
+     */
+    isIgnoreGetters?: boolean;
+    /**
+     * Error handling when getting a result from a getter method.
+     * * If the method returns `true`, then the recursive search will continue.
+     * * If the method returns `false`, then the recursive search terminates immediately.
+     */
+    continueAfterGetterError?: (error: unknown) => boolean;
+}
+
+
+
+/** Recursive search on entity fields */
+export function findRecursively(obj: unknown, options: IFindRecursivelyOptions = {}): FindRecursivelyResult {
+    /** {value: path[]} */
+    const seen = new Map<unknown, Array<string>>();
+    const searched: Record<string, unknown> = {};
+    const needSeen = new Set<IFindRecursivelyMatherOptions>([{
+        value: obj,
+        depth: 0,
+        path: '',
+    }]);
+    const {
+        matcher = falseStub,
+        filter = trueStub,
+        continueAfterGetterError = trueStub,
+        stop = falseStub,
+        minDepth = 1,
+        maxDepth = Infinity,
+    } = options;
+    const pathRegExpCheck =  options.pathRegExp
+        ? (path?: string) => path ? options.pathRegExp?.test(path) : false
+        : falseStub;
+    const fieldRegExpCheck =  options.fieldRegExp
+        ? (field?: unknown) => typeof field === 'string' ? options.fieldRegExp?.test(field) : false
+        : falseStub;
+    let needStop: boolean = false;
+
+    function checkForNeedSeen(options: IFindRecursivelyMatherOptions) {
+        if (options.depth > maxDepth) {
+            return;
+        }
+        const isPrimitiveOrFunction = options.value === null || typeof options.value !== 'object';
+        if (!isPrimitiveOrFunction) {
+            const seenPathsForValue: Array<string> | undefined = seen.get(options.value);
+            if (seenPathsForValue) {
+                // TODO windows or document
+                // TODO List of visited objects, but with the wrong path
+                const hasCircularPath = seenPathsForValue.some(path => options.path.includes(path));
+                if (hasCircularPath) {
+                    return;
+                }
+            }
+            if (filter(options)) {
+                needSeen.add(options);
+                if (seenPathsForValue) {
+                    seenPathsForValue.push(options.path);
+                } else {
+                    seen.set(options.value, [options.path]);
+                }
+            }
+        }
+        if (options.depth < minDepth) {
+            return;
+        }
+        if (matcher(options) || pathRegExpCheck(options.path) || fieldRegExpCheck(options.field)) {
+            searched[options.path || '{}'] = options.value;
+            if (stop(searched)) {
+                needStop = true;
+            }
+        }
+    }
+
+    function iterateArrayLike(
+        iterator: IterableIterator<[unknown, unknown]>,
+        pathBuilder: (fieldIndex: unknown) => string,
+        incrementalDepth: number,
+    ): void {
+        for (const [fieldIndex, fieldValue] of iterator) {
+            checkForNeedSeen({
+                field: fieldIndex,
+                value: fieldValue,
+                path: pathBuilder(fieldIndex),
+                depth: incrementalDepth,
+            });
+            if (needStop) {
+                return;
+            }
+        }
+    }
+
+    while (!needStop) {
+        const iterator = needSeen.values().next();
+        if (iterator.done) {
+            break;
+        }
+        const {value, path, depth} = iterator.value;
+        const incrementalDepth = depth + 1;
+        needSeen.delete(iterator.value);
+
+        if (value instanceof Array) {
+            iterateArrayLike(
+                (value as unknown[]).entries(),
+                (fieldIndex) => `${path}[${fieldIndex}]`,
+                incrementalDepth,
+            );
+        } else if (value instanceof Map) {
+            iterateArrayLike(
+                (value as Map<unknown, unknown>).entries(),
+                (fieldIndex) => `${path}{${fieldIndex}}`,
+                incrementalDepth,
+            );
+        } else if (value instanceof Set) {
+            for (const [fieldIndex, fieldValue] of ([...value] as unknown[]).entries()) {
+                checkForNeedSeen({
+                    field: fieldValue,
+                    value: fieldValue,
+                    path: `${path || ''}<${fieldIndex}>`,
+                    depth: incrementalDepth,
+                });
+                if (needStop) {
+                    break;
+                }
+            }
+        } else if (typeof value === "object") {
+            for (const key of Object.keys(value as object)) {
+                let fieldValue: unknown;
+                if (Object.getOwnPropertyDescriptor(value, key)?.get && options.isIgnoreGetters) {
+                    continue;
+                }
+                try {
+                    fieldValue = (value as any)[key];
+                } catch (error: unknown) {
+                    if (!continueAfterGetterError(error)) {
+                        needStop = true;
+                        break;
+                    }
+                    fieldValue = error;
+                }
+
+                checkForNeedSeen({
+                    field: key,
+                    value: fieldValue,
+                    path: path ? `${path}.${key}` : key,
+                    depth: incrementalDepth
+                });
+                if (needStop) {
+                    break;
+                }
+            }
+        }
+    }
+
+    if (Object.keys(searched).length === 0) {
+        return null;
+    }
+    return searched;
+}

package/src/utils/random-from-array.ts

@@ -1,6 +1,6 @@
-export function randomFromArray<T>(array: T[], from: number = 0, to: number = array.length): T {
-    if (to < 0) {
-        to = array.length + to;
-    }
-    return array[Math.floor(Math.random() * (to - from)) + from];
-}
+export function randomFromArray<T>(array: T[], from: number = 0, to: number = array.length): T {
+    if (to < 0) {
+        to = array.length + to;
+    }
+    return array[Math.floor(Math.random() * (to - from)) + from];
+}

package/src/utils/stubs.ts

@@ -1,7 +1,7 @@
-export function trueStub(): true {
-    return true;
-}
-
-export function falseStub(): false {
-    return false;
-}
+export function trueStub(): true {
+    return true;
+}
+
+export function falseStub(): false {
+    return false;
+}

package/src/operators/merge-map-string-toggle.ts

@@ -1,36 +0,0 @@
-import { EMPTY, from, Observable, ObservableInput, ObservedValueOf, OperatorFunction, pipe } from "rxjs";
-import { distinctUntilChanged, map, mergeMap, switchMap } from "rxjs/operators";
-
-export interface IMergeMapStringToggleOptions {
-    /**
-     * If the `isTakeUntilToggle` parameter is equal to the `true` value,
-     * the stream will be interrupted as soon as the source string fails validation.
-     *
-     * If the `isTakeUntilToggle` parameter is equal to the `false` value, the stream will never be interrupted.
-     */
-    isTakeUntilToggle?: boolean;
-}
-
-/** The operator creates a separate stream when the source string is validated. */
-export function mergeMapStringToggle<O extends ObservableInput<any>>(
-    condition: RegExp | ((url: string) => boolean),
-    project: (() => O) | O,
-    options?: IMergeMapStringToggleOptions,
-): OperatorFunction<string, ObservedValueOf<O>> {
-    const mapConditionFn = typeof condition === 'function' ? condition : (url: string) => condition.test(url);
-    let urlMatchToggler: (isUrlMatch: boolean) => Observable<ObservedValueOf<O>>;
-    if (typeof project === 'function') {
-        urlMatchToggler = (isUrlMatch: boolean) => isUrlMatch ? from(project()) : EMPTY;
-    } else {
-        urlMatchToggler = (isUrlMatch: boolean) => isUrlMatch ? from(project) : EMPTY;
-    }
-    const mergeOperator = options?.isTakeUntilToggle
-        ? switchMap(urlMatchToggler)
-        : mergeMap(urlMatchToggler);
-
-    return pipe(
-        map(mapConditionFn),
-        distinctUntilChanged(),
-        mergeOperator
-    )
-}