@tachybase/utils 0.23.8

package/lib/measure-execution-time.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var measure_execution_time_exports = {};
+__export(measure_execution_time_exports, {
+  measureExecutionTime: () => measureExecutionTime
+});
+module.exports = __toCommonJS(measure_execution_time_exports);
+async function measureExecutionTime(operation, operationName) {
+  const startTime = Date.now();
+  await operation();
+  const endTime = Date.now();
+  const duration = (endTime - startTime).toFixed(0);
+  console.log(`${operationName} completed in ${duration} milliseconds`);
+}
+__name(measureExecutionTime, "measureExecutionTime");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  measureExecutionTime
+});

package/lib/merge.d.ts

@@ -0,0 +1 @@
+export declare function merge(obj1: any, obj2: any, opts?: any): unknown;

package/lib/merge.js

@@ -0,0 +1,46 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var merge_exports = {};
+__export(merge_exports, {
+  merge: () => merge
+});
+module.exports = __toCommonJS(merge_exports);
+var import_deepmerge = __toESM(require("deepmerge"));
+const overwriteMerge = /* @__PURE__ */ __name((destinationArray, sourceArray, options) => sourceArray, "overwriteMerge");
+function merge(obj1, obj2, opts) {
+  return (0, import_deepmerge.default)(obj1, obj2, {
+    arrayMerge: overwriteMerge,
+    ...opts
+  });
+}
+__name(merge, "merge");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  merge
+});

package/lib/mixin/AsyncEmitter.d.ts

@@ -0,0 +1,3 @@
+export declare class AsyncEmitter {
+    emitAsync(event: string | symbol, ...args: any[]): Promise<boolean>;
+}

package/lib/mixin/AsyncEmitter.js

@@ -0,0 +1,73 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AsyncEmitter_exports = {};
+__export(AsyncEmitter_exports, {
+  AsyncEmitter: () => AsyncEmitter
+});
+module.exports = __toCommonJS(AsyncEmitter_exports);
+const _AsyncEmitter = class _AsyncEmitter {
+  async emitAsync(event, ...args) {
+    const events = this._events;
+    let callbacks = events[event];
+    if (!callbacks) {
+      return false;
+    }
+    const run = /* @__PURE__ */ __name((cb) => {
+      switch (args.length) {
+        // fast cases
+        case 0:
+          cb = cb.call(this);
+          break;
+        case 1:
+          cb = cb.call(this, args[0]);
+          break;
+        case 2:
+          cb = cb.call(this, args[0], args[1]);
+          break;
+        case 3:
+          cb = cb.call(this, args[0], args[1], args[2]);
+          break;
+        // slower
+        default:
+          cb = cb.apply(this, args);
+      }
+      if (cb && (cb instanceof Promise || typeof cb.then === "function")) {
+        return cb;
+      }
+      return Promise.resolve(true);
+    }, "run");
+    if (typeof callbacks === "function") {
+      await run(callbacks);
+    } else if (typeof callbacks === "object") {
+      callbacks = callbacks.slice().filter(Boolean);
+      await callbacks.reduce((prev, next) => {
+        return prev.then((res) => {
+          return run(next).then((result) => Promise.resolve(res.concat(result)));
+        });
+      }, Promise.resolve([]));
+    }
+    return true;
+  }
+};
+__name(_AsyncEmitter, "AsyncEmitter");
+let AsyncEmitter = _AsyncEmitter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncEmitter
+});

package/lib/mixin/index.d.ts

@@ -0,0 +1 @@
+export declare function applyMixins(derivedCtor: any, constructors: any[]): void;

package/lib/mixin/index.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mixin_exports = {};
+__export(mixin_exports, {
+  applyMixins: () => applyMixins
+});
+module.exports = __toCommonJS(mixin_exports);
+function applyMixins(derivedCtor, constructors) {
+  constructors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      Object.defineProperty(
+        derivedCtor.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null)
+      );
+    });
+  });
+}
+__name(applyMixins, "applyMixins");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyMixins
+});

package/lib/notification.d.ts

@@ -0,0 +1 @@
+export declare const showToast: (message: any, type?: string, duration?: number) => void;

package/lib/notification.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var notification_exports = {};
+__export(notification_exports, {
+  showToast: () => showToast
+});
+module.exports = __toCommonJS(notification_exports);
+var import_antd = require("antd");
+const showToast = /* @__PURE__ */ __name((message, type = "info", duration = 5e3) => {
+  import_antd.notification[type]({
+    message,
+    duration
+  });
+}, "showToast");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  showToast
+});

package/lib/number.d.ts

@@ -0,0 +1 @@
+export declare function toFixedByStep(value: any, step: string | number): any;

package/lib/number.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var number_exports = {};
+__export(number_exports, {
+  toFixedByStep: () => toFixedByStep
+});
+module.exports = __toCommonJS(number_exports);
+var import_mini_decimal = require("@rc-component/mini-decimal");
+function toFixedByStep(value, step) {
+  if (typeof value === "undefined" || value === null || value === "") {
+    return "";
+  }
+  const precision = (0, import_mini_decimal.getNumberPrecision)(step);
+  return (0, import_mini_decimal.toFixed)(String(value), ".", precision);
+}
+__name(toFixedByStep, "toFixedByStep");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toFixedByStep
+});

package/lib/parse-date.d.ts

@@ -0,0 +1,3 @@
+export declare function parseDate(value: any, options?: {
+    timezone?: string;
+}): string | any[];

package/lib/parse-date.js

@@ -0,0 +1,237 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parse_date_exports = {};
+__export(parse_date_exports, {
+  parseDate: () => parseDate
+});
+module.exports = __toCommonJS(parse_date_exports);
+var import_date = require("./date");
+var import_dayjs = require("./dayjs");
+function parseUTC(value) {
+  if (value instanceof Date || import_dayjs.dayjs.isDayjs(value)) {
+    return {
+      unit: "utc",
+      start: value.toISOString()
+    };
+  }
+  if (value.endsWith("Z")) {
+    return {
+      unit: "utc",
+      start: value
+    };
+  }
+}
+__name(parseUTC, "parseUTC");
+function parseYear(value) {
+  if (/^\d\d\d\d$/.test(value)) {
+    return {
+      unit: "year",
+      start: `${value}-01-01 00:00:00`
+    };
+  }
+}
+__name(parseYear, "parseYear");
+function parseQuarter(value) {
+  if (/^\d\d\d\dQ\d$/.test(value)) {
+    const [year, q] = value.split("Q");
+    return {
+      unit: "quarter",
+      start: (0, import_dayjs.dayjs)(year, "YYYY").quarter(q).format("YYYY-MM-DD HH:mm:ss")
+    };
+  }
+}
+__name(parseQuarter, "parseQuarter");
+function parseWeek(value) {
+  if (/^\d\d\d\d[W]\d\d$/.test(value)) {
+    const arr = value.split("W");
+    return {
+      unit: "isoWeek",
+      start: (0, import_dayjs.dayjs)(arr[0], "YYYY").add(Number(arr[1]), "weeks").format("YYYY-MM-DD HH:mm:ss")
+    };
+  }
+  if (/^\d\d\d\d[w]\d\d$/.test(value)) {
+    const arr = value.split("w");
+    return {
+      unit: "week",
+      start: (0, import_dayjs.dayjs)(arr[0], "YYYY").week(Number(arr[1])).format("YYYY-MM-DD HH:mm:ss")
+    };
+  }
+}
+__name(parseWeek, "parseWeek");
+function parseMonth(value) {
+  if (/^\d\d\d\d\-\d\d$/.test(value)) {
+    return {
+      unit: "month",
+      start: `${value}-01 00:00:00`
+    };
+  }
+}
+__name(parseMonth, "parseMonth");
+function parseDay(value) {
+  if (/^\d\d\d\d\-\d\d\-\d\d$/.test(value)) {
+    return {
+      unit: "day",
+      start: `${value} 00:00:00`
+    };
+  }
+}
+__name(parseDay, "parseDay");
+function parseHour(value) {
+  if (/^\d\d\d\d\-\d\d\-\d\d(\T|\s)\d\d$/.test(value)) {
+    return {
+      unit: "hour",
+      start: `${value}:00:00`
+    };
+  }
+}
+__name(parseHour, "parseHour");
+function parseMinute(value) {
+  if (/^\d\d\d\d\-\d\d\-\d\d(\T|\s)\d\d\:\d\d$/.test(value)) {
+    return {
+      unit: "minute",
+      start: `${value}:00`
+    };
+  }
+}
+__name(parseMinute, "parseMinute");
+function parseSecond(value) {
+  if (/^\d\d\d\d\-\d\d\-\d\d(\T|\s)\d\d\:\d\d\:\d\d$/.test(value)) {
+    return {
+      unit: "second",
+      start: `${value}`
+    };
+  }
+}
+__name(parseSecond, "parseSecond");
+function parseMillisecond(value) {
+  if (/^\d\d\d\d\-\d\d\-\d\d(\T|\s)\d\d\:\d\d\:\d\d\.\d\d\d$/.test(value)) {
+    return {
+      unit: "millisecond",
+      start: `${value}`
+    };
+  }
+}
+__name(parseMillisecond, "parseMillisecond");
+const parsers = [
+  parseUTC,
+  parseYear,
+  parseQuarter,
+  parseWeek,
+  parseMonth,
+  parseDay,
+  parseHour,
+  parseMinute,
+  parseSecond,
+  parseMillisecond
+];
+function toISOString(m) {
+  return m.toISOString();
+}
+__name(toISOString, "toISOString");
+function dateRange(r) {
+  if (!r.timezone) {
+    r.timezone = "+00:00";
+  }
+  let m;
+  if (r.unit === "utc") {
+    return (0, import_dayjs.dayjs)(r == null ? void 0 : r.start).toISOString();
+  } else {
+    m = (0, import_dayjs.dayjs)(`${r == null ? void 0 : r.start}${r == null ? void 0 : r.timezone}`);
+  }
+  m = m.utcOffset((0, import_date.offsetFromString)(r.timezone));
+  return [m = m.startOf(r.unit), m.add(1, r.unit === "isoWeek" ? "weeks" : r.unit).startOf(r.unit)].map(toISOString);
+}
+__name(dateRange, "dateRange");
+function parseDate(value, options = {}) {
+  if (!value) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    return parseDateBetween(value, options);
+  }
+  let timezone = options.timezone || "+00:00";
+  const input = value;
+  if (typeof value === "string") {
+    const match = /(.+)((\+|\-)\d\d\:\d\d)$/.exec(value);
+    if (match) {
+      value = match[1];
+      timezone = match[2];
+    }
+    if (/^(\(|\[)/.test(value)) {
+      return parseDateBetween(input, options);
+    }
+  }
+  for (const parse of parsers) {
+    const r = parse(value);
+    if (r) {
+      r["input"] = input;
+      if (!r["timezone"]) {
+        r["timezone"] = timezone;
+      }
+      return dateRange(r);
+    }
+  }
+}
+__name(parseDate, "parseDate");
+function parseDateBetween(value, options = {}) {
+  if (Array.isArray(value) && value.length > 1) {
+    const [startValue, endValue, op = "[]", timezone2] = value;
+    const r0 = parseDate(startValue, { timezone: timezone2 });
+    const r1 = parseDate(endValue, { timezone: timezone2 });
+    let start;
+    let startOp;
+    let end;
+    let endOp;
+    if (typeof r0 === "string") {
+      start = r0;
+      startOp = op[0];
+    } else {
+      start = op.startsWith("(") ? r0[1] : r0[0];
+      startOp = "[";
+    }
+    if (typeof r1 === "string") {
+      end = r1;
+      endOp = op[1];
+    } else {
+      end = op.endsWith(")") ? r1[0] : r1[1];
+      endOp = ")";
+    }
+    const newOp = startOp + endOp;
+    return newOp === "[)" ? [start, end] : [start, end, newOp];
+  }
+  if (typeof value !== "string") {
+    return;
+  }
+  const match = /(.+)((\+|\-)\d\d\:\d\d)$/.exec(value);
+  let timezone = options.timezone || "+00:00";
+  if (match) {
+    value = match[1];
+    timezone = match[2];
+  }
+  const m = /^(\(|\[)(.+)\,(.+)(\)|\])$/.exec(value);
+  if (!m) {
+    return;
+  }
+  return parseDateBetween([m[2], m[3], `${m[1]}${m[4]}`, timezone]);
+}
+__name(parseDateBetween, "parseDateBetween");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseDate
+});

package/lib/parse-filter.d.ts

@@ -0,0 +1,146 @@
+export declare function flatten(target: any, opts?: any): {};
+export declare function unflatten(obj: any, opts?: any): {};
+export type ParseFilterOptions = {
+    vars?: Record<string, any>;
+    now?: any;
+    timezone?: string;
+    getField?: any;
+};
+export declare const parseFilter: (filter: any, opts?: ParseFilterOptions) => Promise<{}>;
+export type GetDayRangeOptions = {
+    now?: any;
+    timezone?: string | number;
+    offset: number;
+};
+export declare function getDayRange(options: GetDayRangeOptions): (string | number)[];
+export type Utc2unitOptions = {
+    now?: any;
+    unit: any;
+    timezone?: string | number;
+    offset?: number;
+};
+export declare function utc2unit(options: Utc2unitOptions): any;
+export declare function getDateVars(): {
+    now: string;
+    today: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    yesterday: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    tomorrow: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    thisWeek: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    lastWeek: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    nextWeek: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    thisIsoWeek: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    lastIsoWeek: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    nextIsoWeek: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    thisMonth: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    lastMonth: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    nextMonth: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    thisQuarter: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    lastQuarter: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    nextQuarter: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    thisYear: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    lastYear: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    nextYear: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => any;
+    last7Days: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => (string | number)[];
+    next7Days: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => (string | number)[];
+    last30Days: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => (string | number)[];
+    next30Days: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => (string | number)[];
+    last90Days: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => (string | number)[];
+    next90Days: ({ now, timezone, field }: {
+        now: any;
+        timezone: any;
+        field: any;
+    }) => (string | number)[];
+};
+export declare function splitPathToTwoParts(path: string): string[];