@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/core/utils/common.mjs

@@ -0,0 +1,313 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+// eslint-disable-next-line no-restricted-imports
+import { last, isEqual as _isEqual, pick, mapValues } from 'lodash-es';
+import { Bracket } from '../constants/constants';
+export const numToStr = (num) => {
+    if (num === 0) {
+        return '0';
+    }
+    if (!num) {
+        return '';
+    }
+    return num
+        .toLocaleString('fullwide', {
+        minimumFractionDigits: 3,
+        useGrouping: false,
+    })
+        .replace(/([^.])\.?0+$/, '$1');
+};
+export const shortNum = (num, digits = 2) => {
+    if (typeof num === 'string') {
+        num = num.trim();
+    }
+    if (num === 0 || num === '0') {
+        return '0';
+    }
+    if (!num) {
+        return '';
+    }
+    return numToStr(+(+num).toFixed(digits) || Math.pow(10, -digits));
+};
+export const isBlank = (str) => str == null || Number.isNaN(str) || !str.toString().trim();
+export const getBaseHref = () => {
+    // The last base element has highest privilege
+    const base = last(document.querySelectorAll('base'));
+    // use `getAttribute` instead of `base.href` because the attribute could be void but results current whole location url
+    return base?.getAttribute('href') || '/';
+};
+export const ifExist = (toCheck, truthyValue, fallback) => (toCheck ? truthyValue : (fallback || ''));
+export const isAbsoluteUrl = (url) => /^(https?:\/)?\//.test(url);
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export const noop = () => { };
+export const toKeys = (source) => Object.keys(source).reduce((acc, k) => {
+    const key = k;
+    acc[key] = key;
+    return acc;
+}, {});
+export const wrapText = (text, wrapper = Bracket.PARENTHESES, fallback) => (text ? wrapper.join(text) : fallback || '');
+export function parseJSONStream(text) {
+    return text
+        .split('\n')
+        .map(v => {
+        try {
+            return JSON.parse(v);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter(v => !!v);
+}
+export const trackByUid = (_, resource) => resource.metadata.uid;
+export const isK8sResource = (value) => value &&
+    typeof value === 'object' &&
+    'apiVersion' in value &&
+    typeof value.apiVersion === 'string' &&
+    'kind' in value &&
+    typeof value.kind === 'string' &&
+    'metadata' in value &&
+    value.metadata &&
+    typeof value.metadata === 'object';
+export const arrayify = (...args) => args.reduce((arr, curr) => {
+    arr.push(...(Array.isArray(curr) ? curr : curr == null ? [] : [curr]));
+    return arr;
+}, []);
+export function sleep(ms = 0) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+export const delay = sleep;
+export function scrollIntoView(container, selected) {
+    if (!selected) {
+        container.scrollTop = 0;
+        return;
+    }
+    const top = selected.offsetTop;
+    const bottom = selected.offsetTop + selected.offsetHeight;
+    const viewRectTop = container.scrollTop;
+    const viewRectBottom = viewRectTop + container.clientHeight;
+    if (viewRectTop > top) {
+        container.scrollTop = top;
+    }
+    else if (viewRectBottom < bottom) {
+        container.scrollTop = bottom - container.clientHeight;
+    }
+}
+export const isEqual = _isEqual;
+export const parseJson = (str, defaultValue = null) => {
+    if (str === undefined) {
+        return defaultValue;
+    }
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        return defaultValue;
+    }
+};
+export function isJsonObjectString(str) {
+    try {
+        const parsed = JSON.parse(str);
+        return typeof parsed === 'object' && parsed !== null;
+    }
+    catch {
+        return false;
+    }
+}
+export const parseValidImageName = (image) => image?.replace(/([^:])\/\//g, '$1/') || image;
+export const atobWithFallback = (str, fallbackValue = null) => {
+    try {
+        return window.atob(str);
+    }
+    catch {
+        return fallbackValue;
+    }
+};
+/**
+ * 带重复检查的assign，只做一级key的重复检查
+ * 如果有重复项默认会throw error，如果你明确这不是一个关键性错误，则可以通过指定notice函数修改该默认行为
+ * @param sources
+ * @param optionsOrNotice
+ * @return object 一个全新的对象
+ */
+export const safeAssign = (sources, optionsOrNotice) => {
+    if (sources.length === 1) {
+        return sources[0];
+    }
+    const option = {
+        notice: (duplicates) => {
+            throw new Error(`There are duplicate definitions: ${duplicates.join(',')}`);
+        },
+    };
+    if (typeof optionsOrNotice === 'function') {
+        option.notice = optionsOrNotice;
+    }
+    if (typeof optionsOrNotice === 'object') {
+        Object.assign(option, optionsOrNotice);
+    }
+    const duplicates = new Set();
+    const allKey = new Set(Object.keys(sources[0]));
+    sources.slice(1).forEach(obj => {
+        Object.keys(obj).forEach(key => {
+            if (allKey.has(key)) {
+                duplicates.add(key);
+            }
+            else {
+                allKey.add(key);
+            }
+        });
+    });
+    if (duplicates.size) {
+        option.notice([...duplicates]);
+    }
+    return Object.assign({}, ...sources);
+};
+export const toLowerFirstLetter = (text) => typeof text === 'string' && text.length > 0
+    ? text.replace(text[0], text[0].toLocaleLowerCase())
+    : text;
+export const loadEnv = (envText) => {
+    if (!envText)
+        return [];
+    return envText
+        .split('\n')
+        .filter(s => !!s.trim())
+        .map(s => {
+        const index = s.trim().includes('=')
+            ? s.trim().indexOf('=')
+            : s.trim().length;
+        return [
+            s.trim().slice(0, index).trim(),
+            s
+                .trim()
+                .slice(index + 1)
+                .trim(),
+        ];
+    });
+};
+export function filterEmptyValue(obj) {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        if (value !== undefined && value !== null) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+const IMAGE_TYPE_MAPPER = {
+    '/': 'jpg',
+    i: 'png',
+    P: 'svg+xml',
+    R: 'gif',
+};
+export function parseBase64Type(base64Str) {
+    const firstChar = base64Str.charAt(0);
+    return IMAGE_TYPE_MAPPER[firstChar];
+}
+export function appendImageHeader(value, prefix) {
+    if (!value || value.startsWith('data:image/')) {
+        return value;
+    }
+    const header = prefix || `data:image/${parseBase64Type(value) || 'jpg'};base64,`;
+    return `${header}${value}`;
+}
+export const getRelativePath = (from, to) => {
+    const fromParts = (from ?? '').split('/').filter(p => p !== '');
+    const toParts = (to ?? '').split('/').filter(p => p !== '');
+    let relativePath = '';
+    while (fromParts.length > 0 &&
+        toParts.length > 0 &&
+        fromParts[0] === toParts[0]) {
+        fromParts.shift();
+        toParts.shift();
+    }
+    relativePath = '../'.repeat(fromParts.length);
+    relativePath += toParts.join('/');
+    return relativePath;
+};
+export const getToPath = (from, relative) => {
+    const fromParts = from.split('/').filter(p => p !== '');
+    const relativeParts = relative.split('/').filter(p => p !== '');
+    const dotDotCount = +relativeParts.filter(p => p === '..')?.length;
+    const s = fromParts.splice(0, fromParts.length - dotDotCount);
+    return s.concat(relativeParts.splice(dotDotCount)).join('/');
+};
+export const trackByName = (_, resource) => resource.metadata.name;
+export function tableSort(list, sort, sortActiveValueFn) {
+    return list.slice().sort((a, b) => {
+        const key = sort.active;
+        const keyA = sortActiveValueFn(a, key);
+        const keyB = sortActiveValueFn(b, key);
+        if (keyA === keyB)
+            return 0;
+        return sort.direction === 'asc'
+            ? keyA > keyB
+                ? 1
+                : -1
+            : keyB > keyA
+                ? 1
+                : -1;
+    });
+}
+// 支持中文排序，推荐使用
+export function tableSortAdvance(list, sort, sortActiveValueFn) {
+    return list.slice().sort((a, b) => {
+        const key = sort.active;
+        const keyA = sortActiveValueFn(a, key).toString();
+        const keyB = sortActiveValueFn(b, key).toString();
+        if (keyA === keyB)
+            return 0;
+        return sort.direction === 'asc'
+            ? keyA.localeCompare(keyB)
+            : keyB.localeCompare(keyA);
+    });
+}
+// 将节点名转成地址
+export const nodeName2Address = (name) => {
+    if (name?.startsWith('v6-')) {
+        // 是v6协议
+        return name.slice(3).replaceAll('-', ':');
+    }
+    return name;
+};
+// 根据 tagOrDigest 生成镜像地址
+export const buildImageAddress = (url, tagOrDigest) => {
+    return `${url}${tagOrDigest.startsWith('sha256:') ? '@' : ':'}${tagOrDigest}`;
+};
+// 解析镜像地址
+export const parseImageAddress = (addr) => {
+    const result = {
+        url: '',
+    };
+    const [urlPart, digestPart] = addr.split('@sha256');
+    if (digestPart) {
+        result.digest = `sha256${digestPart}`;
+    }
+    const tagIndex = urlPart.lastIndexOf(':');
+    if (tagIndex > 0 && tagIndex > urlPart.lastIndexOf('/')) {
+        result.tag = urlPart.slice(tagIndex + 1);
+        result.url = urlPart.slice(0, tagIndex);
+    }
+    else {
+        result.url = urlPart;
+    }
+    return result;
+};
+const allowedApis = [
+    'hasSelection',
+    'getSelection',
+    'getSelectionPosition',
+    'clearSelection',
+    'select',
+    'selectAll',
+    'selectLines',
+];
+export const setWindowsXtermTools = (xterm) => {
+    window.__XTERM_TOOLS__ = mapValues(pick(xterm, allowedApis), (fun) => fun.bind(xterm));
+};
+export const clearWindowsXtermTools = () => {
+    delete window.__XTERM_TOOLS__;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/utils/common.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\nimport { Sort } from '@alauda/ui';\n// eslint-disable-next-line no-restricted-imports\nimport { last, isEqual as _isEqual, pick, mapValues } from 'lodash-es';\nimport { UnionToIntersection, ValueOf } from 'ts-essentials';\nimport { Terminal } from 'xterm';\n\nimport { Bracket } from '../constants/constants';\nimport {\n  Callback,\n  Keys,\n  KubernetesResource,\n  Nullable,\n  Readonlyable,\n  StringMap,\n} from '../types/public-api';\n\nexport const numToStr = (num?: number) => {\n  if (num === 0) {\n    return '0';\n  }\n\n  if (!num) {\n    return '';\n  }\n\n  return num\n    .toLocaleString('fullwide', {\n      minimumFractionDigits: 3,\n      useGrouping: false,\n    })\n    .replace(/([^.])\\.?0+$/, '$1');\n};\n\nexport const shortNum = (num?: number | string, digits = 2) => {\n  if (typeof num === 'string') {\n    num = num.trim();\n  }\n  if (num === 0 || num === '0') {\n    return '0';\n  }\n  if (!num) {\n    return '';\n  }\n  return numToStr(+(+num).toFixed(digits) || Math.pow(10, -digits));\n};\n\nexport const isBlank = (str?: unknown) =>\n  str == null || Number.isNaN(str as number) || !str.toString().trim();\n\nexport const getBaseHref = () => {\n  // The last base element has highest privilege\n  const base = last(document.querySelectorAll('base'));\n  // use `getAttribute` instead of `base.href` because the attribute could be void but results current whole location url\n  return base?.getAttribute('href') || '/';\n};\n\nexport const ifExist = <T>(\n  toCheck: boolean | Nullable<T>,\n  truthyValue: T,\n  fallback?: T,\n) => (toCheck ? truthyValue : ((fallback || '') as T));\n\nexport const isAbsoluteUrl = (url: string) => /^(https?:\\/)?\\//.test(url);\n\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport const noop: Callback = () => {};\n\nexport const toKeys = <T extends object>(source: T): Keys<T> =>\n  Object.keys(source).reduce((acc, k) => {\n    const key = k as keyof T;\n    acc[key] = key;\n    return acc;\n  }, {} as Keys<T>);\n\nexport const wrapText = (\n  text?: string,\n  wrapper: Readonlyable<[string, string]> = Bracket.PARENTHESES,\n  fallback?: string,\n) => (text ? wrapper.join(text) : fallback || '');\n\nexport function parseJSONStream<T>(text: string): T[] {\n  return text\n    .split('\\n')\n    .map(v => {\n      try {\n        return JSON.parse(v);\n      } catch {\n        return null;\n      }\n    })\n    .filter(v => !!v);\n}\n\nexport const trackByUid = <T extends KubernetesResource>(\n  _: number,\n  resource: T,\n) => resource.metadata.uid;\n\nexport const isK8sResource = <\n  T extends KubernetesResource = KubernetesResource,\n>(\n  value: object,\n): value is T =>\n  value &&\n  typeof value === 'object' &&\n  'apiVersion' in value &&\n  typeof value.apiVersion === 'string' &&\n  'kind' in value &&\n  typeof value.kind === 'string' &&\n  'metadata' in value &&\n  value.metadata &&\n  typeof value.metadata === 'object';\n\nexport const arrayify = <\n  T,\n  R = T extends Array<infer S> ? NonNullable<S> : NonNullable<T>,\n>(\n  ...args: Array<R | R[]>\n) =>\n  args.reduce<R[]>((arr, curr) => {\n    arr.push(...(Array.isArray(curr) ? curr : curr == null ? [] : [curr]));\n    return arr;\n  }, []);\n\nexport function sleep(ms = 0) {\n  return new Promise(resolve => {\n    setTimeout(resolve, ms);\n  });\n}\n\nexport const delay = sleep;\n\nexport function scrollIntoView(container: HTMLElement, selected: HTMLElement) {\n  if (!selected) {\n    container.scrollTop = 0;\n    return;\n  }\n\n  const top = selected.offsetTop;\n  const bottom = selected.offsetTop + selected.offsetHeight;\n  const viewRectTop = container.scrollTop;\n  const viewRectBottom = viewRectTop + container.clientHeight;\n\n  if (viewRectTop > top) {\n    container.scrollTop = top;\n  } else if (viewRectBottom < bottom) {\n    container.scrollTop = bottom - container.clientHeight;\n  }\n}\n\nexport const isEqual: <T, V = T>(a: T, b: V) => boolean = _isEqual;\n\nexport const parseJson = <T>(str: string, defaultValue: T = null) => {\n  if (str === undefined) {\n    return defaultValue;\n  }\n  try {\n    return JSON.parse(str);\n  } catch {\n    return defaultValue;\n  }\n};\n\nexport function isJsonObjectString(str: string): boolean {\n  try {\n    const parsed = JSON.parse(str);\n    return typeof parsed === 'object' && parsed !== null;\n  } catch {\n    return false;\n  }\n}\n\nexport const parseValidImageName = (image: string) =>\n  image?.replace(/([^:])\\/\\//g, '$1/') || image;\n\nexport const atobWithFallback = (str: string, fallbackValue: string = null) => {\n  try {\n    return window.atob(str);\n  } catch {\n    return fallbackValue;\n  }\n};\n\nexport interface SafeAssignOptions {\n  notice: (duplicates: string[]) => any;\n}\n/**\n * 带重复检查的assign，只做一级key的重复检查\n * 如果有重复项默认会throw error，如果你明确这不是一个关键性错误，则可以通过指定notice函数修改该默认行为\n * @param sources\n * @param optionsOrNotice\n * @return object 一个全新的对象\n */\nexport const safeAssign = <T extends Record<string, any>>(\n  sources: T[],\n  optionsOrNotice?: SafeAssignOptions['notice'] | SafeAssignOptions,\n): UnionToIntersection<T> => {\n  if (sources.length === 1) {\n    return sources[0] as UnionToIntersection<T>;\n  }\n\n  const option: SafeAssignOptions = {\n    notice: (duplicates: string[]) => {\n      throw new Error(\n        `There are duplicate definitions: ${duplicates.join(',')}`,\n      );\n    },\n  };\n  if (typeof optionsOrNotice === 'function') {\n    option.notice = optionsOrNotice;\n  }\n  if (typeof optionsOrNotice === 'object') {\n    Object.assign(option, optionsOrNotice);\n  }\n\n  const duplicates = new Set<string>();\n  const allKey = new Set(Object.keys(sources[0]));\n  sources.slice(1).forEach(obj => {\n    Object.keys(obj).forEach(key => {\n      if (allKey.has(key)) {\n        duplicates.add(key);\n      } else {\n        allKey.add(key);\n      }\n    });\n  });\n  if (duplicates.size) {\n    option.notice([...duplicates]);\n  }\n  return Object.assign({}, ...sources);\n};\n\nexport const toLowerFirstLetter = (text: string) =>\n  typeof text === 'string' && text.length > 0\n    ? text.replace(text[0], text[0].toLocaleLowerCase())\n    : text;\n\nexport const loadEnv = (envText: string): Array<[string, string]> => {\n  if (!envText) return [];\n  return envText\n    .split('\\n')\n    .filter(s => !!s.trim())\n    .map(s => {\n      const index = s.trim().includes('=')\n        ? s.trim().indexOf('=')\n        : s.trim().length;\n      return [\n        s.trim().slice(0, index).trim(),\n        s\n          .trim()\n          .slice(index + 1)\n          .trim(),\n      ];\n    });\n};\n\nexport function filterEmptyValue<T extends Record<string, unknown>>(\n  obj: T,\n): Partial<T> {\n  return Object.entries(obj).reduce((acc, [key, value]) => {\n    if (value !== undefined && value !== null) {\n      acc[key as keyof T] = value as T[keyof T];\n    }\n    return acc;\n  }, {} as Partial<T>);\n}\n\nconst IMAGE_TYPE_MAPPER: StringMap = {\n  '/': 'jpg',\n  i: 'png',\n  P: 'svg+xml',\n  R: 'gif',\n};\n\nexport function parseBase64Type(base64Str: string) {\n  const firstChar = base64Str.charAt(0);\n  return IMAGE_TYPE_MAPPER[firstChar];\n}\n\nexport function appendImageHeader(value: string, prefix?: string): string {\n  if (!value || value.startsWith('data:image/')) {\n    return value;\n  }\n  const header =\n    prefix || `data:image/${parseBase64Type(value) || 'jpg'};base64,`;\n  return `${header}${value}`;\n}\n\nexport const getRelativePath = (from: string, to: string) => {\n  const fromParts = (from ?? '').split('/').filter(p => p !== '');\n  const toParts = (to ?? '').split('/').filter(p => p !== '');\n\n  let relativePath = '';\n  while (\n    fromParts.length > 0 &&\n    toParts.length > 0 &&\n    fromParts[0] === toParts[0]\n  ) {\n    fromParts.shift();\n    toParts.shift();\n  }\n\n  relativePath = '../'.repeat(fromParts.length);\n\n  relativePath += toParts.join('/');\n\n  return relativePath;\n};\n\nexport const getToPath = (from: string, relative: string) => {\n  const fromParts = from.split('/').filter(p => p !== '');\n  const relativeParts = relative.split('/').filter(p => p !== '');\n\n  const dotDotCount = +relativeParts.filter(p => p === '..')?.length;\n\n  const s = fromParts.splice(0, fromParts.length - dotDotCount);\n\n  return s.concat(relativeParts.splice(dotDotCount)).join('/');\n};\n\nexport const trackByName = <T extends KubernetesResource>(\n  _: number,\n  resource: T,\n) => resource.metadata.name;\n\nexport function tableSort<T>(\n  list: T[],\n  sort: Sort,\n  sortActiveValueFn: (item: T, name: string) => string | number,\n): T[] {\n  return list.slice().sort((a, b) => {\n    const key = sort.active;\n    const keyA = sortActiveValueFn(a, key);\n    const keyB = sortActiveValueFn(b, key);\n    if (keyA === keyB) return 0;\n    return sort.direction === 'asc'\n      ? keyA > keyB\n        ? 1\n        : -1\n      : keyB > keyA\n      ? 1\n      : -1;\n  });\n}\n\n// 支持中文排序，推荐使用\nexport function tableSortAdvance<T>(\n  list: T[],\n  sort: Sort,\n  sortActiveValueFn: (item: T, name: string) => string | number,\n): T[] {\n  return list.slice().sort((a, b) => {\n    const key = sort.active;\n    const keyA = sortActiveValueFn(a, key).toString();\n    const keyB = sortActiveValueFn(b, key).toString();\n    if (keyA === keyB) return 0;\n    return sort.direction === 'asc'\n      ? keyA.localeCompare(keyB)\n      : keyB.localeCompare(keyA);\n  });\n}\n\n// 将节点名转成地址\nexport const nodeName2Address = (name: string) => {\n  if (name?.startsWith('v6-')) {\n    // 是v6协议\n    return name.slice(3).replaceAll('-', ':');\n  }\n  return name;\n};\n\n// 根据 tagOrDigest 生成镜像地址\nexport const buildImageAddress = (url: string, tagOrDigest: string) => {\n  return `${url}${tagOrDigest.startsWith('sha256:') ? '@' : ':'}${tagOrDigest}`;\n};\n\n// 解析镜像地址\nexport const parseImageAddress = (addr: string) => {\n  const result: {\n    digest?: string;\n    tag?: string;\n    url: string;\n  } = {\n    url: '',\n  };\n\n  const [urlPart, digestPart] = addr.split('@sha256');\n  if (digestPart) {\n    result.digest = `sha256${digestPart}`;\n  }\n\n  const tagIndex = urlPart.lastIndexOf(':');\n  if (tagIndex > 0 && tagIndex > urlPart.lastIndexOf('/')) {\n    result.tag = urlPart.slice(tagIndex + 1);\n    result.url = urlPart.slice(0, tagIndex);\n  } else {\n    result.url = urlPart;\n  }\n\n  return result;\n};\n\nconst allowedApis = [\n  'hasSelection',\n  'getSelection',\n  'getSelectionPosition',\n  'clearSelection',\n  'select',\n  'selectAll',\n  'selectLines',\n] as const;\n\nexport const setWindowsXtermTools = (xterm: Terminal) => {\n  (window as any).__XTERM_TOOLS__ = mapValues(\n    pick(xterm, allowedApis),\n    (fun: ValueOf<Pick<Terminal, ValueOf<typeof allowedApis>>>) =>\n      fun.bind(xterm),\n  );\n};\n\nexport const clearWindowsXtermTools = () => {\n  delete (window as any).__XTERM_TOOLS__;\n};\n"]}

package/esm2022/core/utils/create-recursive-filter.mjs

@@ -0,0 +1,57 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+/** Recursive filter without presume data structure
+ *
+ * @example 1. Nested Tree
+ *
+ * ```
+ * interface Node {
+ *   ...,
+ *   children: Node[]
+ * }
+ *
+ * const filter = createRecursiveFilter(
+ *   (node: Node) => node.children,
+ *   (node: Node, children: Node[]) => ({ ...node, children }),
+ *  );
+ * ```
+ *
+ * @example 2. Normalized Tree
+ *
+ * ```
+ * interface Node {
+ *   id: string;
+ *   children: string[];
+ * }
+ *
+ * interface NodeEntities {
+ *   [id: string]: Node;
+ * }
+ *
+ * const nodes: NodeEntities;
+ *
+ * const filter = createRecursiveFilter(
+ *   (node: Node) => node.children.map(id => nodes[id]),
+ *   (node: Node, children: Node[]) => ({ ...node, children: children.map(child => child.id) }),
+ * );
+ * ```
+ */
+export const createRecursiveFilter = (pickChildren = null, mergeChildren = null) => (items, condition) => {
+    if (!items) {
+        return [];
+    }
+    if (!pickChildren || !mergeChildren) {
+        return items.filter(condition);
+    }
+    const filter = createRecursiveFilter(pickChildren, mergeChildren);
+    return (items?.filter(condition) ?? []).map(item => {
+        const children = pickChildren(item);
+        if (!children || children.length === 0) {
+            return item;
+        }
+        return mergeChildren(item, filter(children, condition));
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/utils/cron-util.mjs

@@ -0,0 +1,44 @@
+export const CRON_ENABLE_7_FOR_SUNDAY = false;
+export const CronWeekDays = [
+    'sun',
+    'mon',
+    'tue',
+    'wed',
+    'thu',
+    'fri',
+    'sat',
+];
+export const WEEK_DAYS = [...CronWeekDays.slice(1), CronWeekDays[0]];
+function formatWeekDaysValue(days) {
+    return days
+        .map(v => (v.length === 3 ? CronWeekDays.indexOf(v) : +v))
+        .sort((a, b) => a - b);
+}
+export function getCronWeekDayNumbers(schedule) {
+    const matches = schedule.match(/(?: ((?:\d|mon|tue|wed|thu|fri|sat|sun)(?:,(?:\d|mon|tue|wed|thu|fri|sat|sun))*)| ((?:\d|mon|tue|wed|thu|fri|sat|sun)-(?:\d|mon|tue|wed|thu|fri|sat|sun)))$/);
+    if (matches) {
+        const days = matches[1] ? matches[1].split(',') : matches[2].split('-');
+        return formatWeekDaysValue(days);
+    }
+    return null;
+}
+export function isCronWeekDayCorrect(schedule) {
+    const dayNumbers = getCronWeekDayNumbers(schedule);
+    return !(!CRON_ENABLE_7_FOR_SUNDAY && dayNumbers && dayNumbers.pop() === 7);
+}
+export function isCronWeekDaysContinuous(days) {
+    if (days.length === 7) {
+        return true;
+    }
+    const sorted = days.sort((a, b) => a - b);
+    const [first, ...others] = sorted;
+    // If sunday exists, move it to end
+    const handled = (first === 0 ? [...others, 7] : [...sorted]).map(item => item - (7 - days.length));
+    return handled.reduce((prev, cur, index) => prev && (index === 0 || handled[index - 1] + 1 === cur), true);
+}
+export function isCronFieldCountCorrect(exp) {
+    const spaceCount = exp.split('').filter(val => val === ' ').length;
+    const fieldCount = exp.split(' ').filter(Boolean).length;
+    return spaceCount === 4 && fieldCount === 5;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/utils/decorators.mjs

@@ -0,0 +1,137 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { debounce } from 'lodash-es';
+import { BehaviorSubject } from 'rxjs';
+const checkDescriptor = (target, propertyKey) => {
+    const oDescriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
+    if (oDescriptor && !oDescriptor.configurable) {
+        throw new TypeError(`property ${String(propertyKey)} is not configurable`);
+    }
+    return {
+        oGetter: oDescriptor?.get,
+        oSetter: oDescriptor?.set,
+        oDescriptor,
+    };
+};
+const strictCheckDescriptor = (target, propertyKey) => {
+    const { oGetter, oSetter, oDescriptor } = checkDescriptor(target, propertyKey);
+    if (oGetter || oSetter) {
+        throw new TypeError(`property ${String(propertyKey)} should not define getter or setter`);
+    }
+    return oDescriptor;
+};
+export function ValueHook(setter, getter, afterSetter) {
+    return (target, propertyKey) => {
+        const { oGetter, oSetter } = checkDescriptor(target, propertyKey);
+        const symbol = Symbol(propertyKey);
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            configurable: true,
+            get() {
+                return getter
+                    ? getter.call(this, this[symbol])
+                    : oGetter
+                        ? oGetter.call(this)
+                        : this[symbol];
+            },
+            set(value) {
+                if (value === this[propertyKey] ||
+                    setter?.call(this, value) === false) {
+                    return;
+                }
+                if (oSetter) {
+                    oSetter.call(this, value);
+                }
+                this[symbol] = value;
+                afterSetter?.call(this, value);
+            },
+        });
+    };
+}
+export function ObservableInput(propertyKey = true, initialValue) {
+    return (target, oPropertyKey) => {
+        if (!oPropertyKey.endsWith('$')) {
+            throw new TypeError(`property ${oPropertyKey} should be an Observable and its name should end with $`);
+        }
+        strictCheckDescriptor(target, oPropertyKey);
+        const symbol = Symbol(oPropertyKey);
+        // eslint-disable-next-line prefer-const
+        let oPropertyValue;
+        Object.defineProperty(target, oPropertyKey, {
+            enumerable: true,
+            configurable: true,
+            get() {
+                return (this[symbol] ||
+                    (this[symbol] = new BehaviorSubject(
+                    // when no initialValue passed in, use the original property val
+                    initialValue === undefined ? oPropertyValue : initialValue)));
+            },
+            set(value) {
+                this[oPropertyKey].next(value);
+            },
+        });
+        if (!propertyKey) {
+            return;
+        }
+        if (propertyKey === true) {
+            propertyKey = oPropertyKey.replace(/\$+$/, '');
+        }
+        const oDescriptor = strictCheckDescriptor(target, propertyKey);
+        oPropertyValue = oDescriptor ? oDescriptor.value : target[propertyKey];
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            configurable: true,
+            get() {
+                return this[oPropertyKey].getValue();
+            },
+            set(value) {
+                this[oPropertyKey].next(value);
+            },
+        });
+    };
+}
+/**
+ * @see https://github.com/NoHomey/bind-decorator
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types -- intended
+export function bind(_target, propertyKey, descriptor) {
+    if (typeof descriptor.value !== 'function') {
+        throw new TypeError(`Only methods can be decorated with @bind. <${propertyKey}> is not a method!`);
+    }
+    return {
+        configurable: true,
+        get() {
+            const bound = descriptor.value.bind(this);
+            // Credits to https://github.com/andreypopp/autobind-decorator for memoizing the result of bind against a symbol on the instance.
+            Object.defineProperty(this, propertyKey, {
+                value: bound,
+                configurable: true,
+                writable: true,
+            });
+            return bound;
+        },
+    };
+}
+// lodash 的 debounce 类型约束要求 (...args: any) => any
+export function debounceFn(delay = 200, options) {
+    return function (_target, propertyKey, descriptor) {
+        if (typeof descriptor.value !== 'function') {
+            throw new TypeError(`Only methods can be decorated with @bind. <${propertyKey}> is not a method!`);
+        }
+        return {
+            configurable: true,
+            get() {
+                const bound = debounce(descriptor.value, delay, options);
+                Object.defineProperty(this, propertyKey, {
+                    value: bound,
+                    configurable: true,
+                    writable: true,
+                });
+                return bound;
+            },
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/utils/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\nimport { DebounceSettings, DebouncedFunc, debounce } from 'lodash-es';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { ObservableType } from '../types/public-api';\n\nconst checkDescriptor = <T, K extends keyof T>(target: T, propertyKey: K) => {\n  const oDescriptor = Object.getOwnPropertyDescriptor(target, propertyKey);\n\n  if (oDescriptor && !oDescriptor.configurable) {\n    throw new TypeError(`property ${String(propertyKey)} is not configurable`);\n  }\n\n  return {\n    oGetter: oDescriptor?.get,\n    oSetter: oDescriptor?.set,\n    oDescriptor,\n  };\n};\n\nconst strictCheckDescriptor = <T, K extends keyof T>(\n  target: T,\n  propertyKey: K,\n) => {\n  const { oGetter, oSetter, oDescriptor } = checkDescriptor(\n    target,\n    propertyKey,\n  );\n\n  if (oGetter || oSetter) {\n    throw new TypeError(\n      `property ${String(propertyKey)} should not define getter or setter`,\n    );\n  }\n\n  return oDescriptor;\n};\n\nexport function ValueHook<T = any, K extends keyof T = any>(\n  setter?: (this: T, value?: T[K]) => boolean | void,\n  getter?: (this: T, value?: T[K]) => T[K],\n  afterSetter?: (this: T, value?: T[K]) => void,\n) {\n  return (target: T, propertyKey: K) => {\n    const { oGetter, oSetter } = checkDescriptor(target, propertyKey);\n\n    const symbol = Symbol(propertyKey as string);\n\n    type Mixed = T & {\n      [symbol]: T[K];\n    };\n\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      configurable: true,\n      get(this: Mixed) {\n        return getter\n          ? getter.call(this, this[symbol])\n          : oGetter\n          ? oGetter.call(this)\n          : this[symbol];\n      },\n      set(this: Mixed, value: T[K]) {\n        if (\n          value === this[propertyKey] ||\n          setter?.call(this, value) === false\n        ) {\n          return;\n        }\n        if (oSetter) {\n          oSetter.call(this, value);\n        }\n        this[symbol] = value;\n        afterSetter?.call(this, value);\n      },\n    });\n  };\n}\n\nexport type ObservableInputPropertyKey<T> = T extends `${infer R}$`\n  ? ObservableInputPropertyKey<R>\n  : T;\n\nexport function ObservableInput<\n  T = any,\n  OK extends keyof T = any,\n  K extends keyof T = ObservableInputPropertyKey<OK> & keyof T,\n>(propertyKey: K | boolean = true, initialValue?: ObservableType<T[OK]>) {\n  return (target: T, oPropertyKey: OK) => {\n    if (!(oPropertyKey as string).endsWith('$')) {\n      throw new TypeError(\n        `property ${\n          oPropertyKey as string\n        } should be an Observable and its name should end with $`,\n      );\n    }\n\n    strictCheckDescriptor(target, oPropertyKey);\n\n    const symbol = Symbol(oPropertyKey as string);\n\n    type OT = ObservableType<T[OK]>;\n\n    type Mixed = T & {\n      [symbol]: BehaviorSubject<OT>;\n    } & Record<OK, BehaviorSubject<OT>>;\n\n    // eslint-disable-next-line prefer-const\n    let oPropertyValue: OT;\n\n    Object.defineProperty(target, oPropertyKey, {\n      enumerable: true,\n      configurable: true,\n      get(this: Mixed) {\n        return (\n          this[symbol] ||\n          (this[symbol] = new BehaviorSubject(\n            // when no initialValue passed in, use the original property val\n            initialValue === undefined ? oPropertyValue : initialValue,\n          ))\n        );\n      },\n      set(this: Mixed, value: OT) {\n        this[oPropertyKey].next(value);\n      },\n    });\n\n    if (!propertyKey) {\n      return;\n    }\n\n    if (propertyKey === true) {\n      propertyKey = (oPropertyKey as string).replace(/\\$+$/, '') as K;\n    }\n\n    const oDescriptor = strictCheckDescriptor(target, propertyKey);\n    oPropertyValue = oDescriptor ? oDescriptor.value : target[propertyKey];\n\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      configurable: true,\n      get(this: Mixed) {\n        return this[oPropertyKey].getValue();\n      },\n      set(this: Mixed, value: OT) {\n        this[oPropertyKey].next(value);\n      },\n    });\n  };\n}\n\n/**\n * @see https://github.com/NoHomey/bind-decorator\n */\n// eslint-disable-next-line @typescript-eslint/ban-types -- intended\nexport function bind<T extends Function>(\n  _target: object,\n  propertyKey: string,\n  descriptor: TypedPropertyDescriptor<T>,\n): TypedPropertyDescriptor<T> | void {\n  if (typeof descriptor.value !== 'function') {\n    throw new TypeError(\n      `Only methods can be decorated with @bind. <${propertyKey}> is not a method!`,\n    );\n  }\n\n  return {\n    configurable: true,\n    get(this: T): T {\n      const bound: T = descriptor.value.bind(this);\n      // Credits to https://github.com/andreypopp/autobind-decorator for memoizing the result of bind against a symbol on the instance.\n      Object.defineProperty(this, propertyKey, {\n        value: bound,\n        configurable: true,\n        writable: true,\n      });\n      return bound;\n    },\n  };\n}\n\n// lodash 的 debounce 类型约束要求 (...args: any) => any\nexport function debounceFn<T extends (...args: any) => any>(\n  delay = 200,\n  options?: DebounceSettings,\n) {\n  return function (\n    _target: object,\n    propertyKey: string,\n    descriptor: TypedPropertyDescriptor<T>,\n  ): TypedPropertyDescriptor<DebouncedFunc<T>> | void {\n    if (typeof descriptor.value !== 'function') {\n      throw new TypeError(\n        `Only methods can be decorated with @bind. <${propertyKey}> is not a method!`,\n      );\n    }\n\n    return {\n      configurable: true,\n      get(this: T): DebouncedFunc<T> {\n        const bound = debounce(descriptor.value, delay, options);\n        Object.defineProperty(this, propertyKey, {\n          value: bound,\n          configurable: true,\n          writable: true,\n        });\n        return bound;\n      },\n    };\n  };\n}\n"]}