@nocobase/plugin-field-sort 1.5.0-alpha.1

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/lib/parse-date.js

@@ -0,0 +1,262 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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,
+  parseWeek: () => parseWeek
+});
+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");
+    const year = (0, import_dayjs.dayjs)(arr[0], "YYYY").format("GGGG");
+    if (year !== arr[0]) {
+      return {
+        unit: "isoWeek",
+        start: (0, import_dayjs.dayjs)(arr[0], "YYYY").add(1, "week").startOf("isoWeek").isoWeek(Number(arr[1])).format("YYYY-MM-DD HH:mm:ss")
+      };
+    }
+    return {
+      unit: "isoWeek",
+      start: (0, import_dayjs.dayjs)(arr[0], "YYYY").isoWeek(Number(arr[1])).format("YYYY-MM-DD HH:mm:ss")
+    };
+  }
+  if (/^\d\d\d\d[w]\d\d$/.test(value)) {
+    const arr = value.split("w");
+    const year = (0, import_dayjs.dayjs)(arr[0], "YYYY").format("gggg");
+    if (year !== arr[0]) {
+      return {
+        unit: "week",
+        start: (0, import_dayjs.dayjs)(arr[0], "YYYY").add(1, "week").startOf("week").week(Number(arr[1])).format("YYYY-MM-DD HH:mm:ss")
+      };
+    }
+    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,
+  parseWeek
+});

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/lib/parse-filter.d.ts

@@ -0,0 +1,67 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+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;
+type ToUnitParams = {
+    now?: any;
+    timezone?: string | number;
+    field?: {
+        timezone?: string | number;
+    };
+};
+export declare const toUnit: (unit: any, offset?: number) => ({ now, timezone, field }: ToUnitParams) => any;
+export declare function getDateVars(): {
+    now: string;
+    today: ({ now, timezone, field }: ToUnitParams) => any;
+    yesterday: ({ now, timezone, field }: ToUnitParams) => any;
+    tomorrow: ({ now, timezone, field }: ToUnitParams) => any;
+    thisWeek: ({ now, timezone, field }: ToUnitParams) => any;
+    lastWeek: ({ now, timezone, field }: ToUnitParams) => any;
+    nextWeek: ({ now, timezone, field }: ToUnitParams) => any;
+    thisIsoWeek: ({ now, timezone, field }: ToUnitParams) => any;
+    lastIsoWeek: ({ now, timezone, field }: ToUnitParams) => any;
+    nextIsoWeek: ({ now, timezone, field }: ToUnitParams) => any;
+    thisMonth: ({ now, timezone, field }: ToUnitParams) => any;
+    lastMonth: ({ now, timezone, field }: ToUnitParams) => any;
+    nextMonth: ({ now, timezone, field }: ToUnitParams) => any;
+    thisQuarter: ({ now, timezone, field }: ToUnitParams) => any;
+    lastQuarter: ({ now, timezone, field }: ToUnitParams) => any;
+    nextQuarter: ({ now, timezone, field }: ToUnitParams) => any;
+    thisYear: ({ now, timezone, field }: ToUnitParams) => any;
+    lastYear: ({ now, timezone, field }: ToUnitParams) => any;
+    nextYear: ({ now, timezone, field }: ToUnitParams) => any;
+    last7Days: ({ now, timezone, field }: ToUnitParams) => (string | number)[];
+    next7Days: ({ now, timezone, field }: ToUnitParams) => (string | number)[];
+    last30Days: ({ now, timezone, field }: ToUnitParams) => (string | number)[];
+    next30Days: ({ now, timezone, field }: ToUnitParams) => (string | number)[];
+    last90Days: ({ now, timezone, field }: ToUnitParams) => (string | number)[];
+    next90Days: ({ now, timezone, field }: ToUnitParams) => (string | number)[];
+};
+export declare function splitPathToTwoParts(path: string): string[];
+export {};

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/lib/parse-filter.js

@@ -0,0 +1,320 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 parse_filter_exports = {};
+__export(parse_filter_exports, {
+  flatten: () => flatten,
+  getDateVars: () => getDateVars,
+  getDayRange: () => getDayRange,
+  parseFilter: () => parseFilter,
+  splitPathToTwoParts: () => splitPathToTwoParts,
+  toUnit: () => toUnit,
+  unflatten: () => unflatten,
+  utc2unit: () => utc2unit
+});
+module.exports = __toCommonJS(parse_filter_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_set = __toESM(require("lodash/set"));
+var import_moment = __toESM(require("moment"));
+var import_date = require("./date");
+var import_dayjs = require("./dayjs");
+var import_getValuesByPath = require("./getValuesByPath");
+const re = /^\s*\{\{([\s\S]*)\}\}\s*$/;
+function isBuffer(obj) {
+  return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+}
+__name(isBuffer, "isBuffer");
+function keyIdentity(key) {
+  return key;
+}
+__name(keyIdentity, "keyIdentity");
+function flatten(target, opts) {
+  opts = opts || {};
+  const delimiter = opts.delimiter || ".";
+  const maxDepth = opts.maxDepth;
+  const transformKey = opts.transformKey || keyIdentity;
+  const transformValue = opts.transformValue || keyIdentity;
+  const output = {};
+  function step(object, prev, currentDepth) {
+    currentDepth = currentDepth || 1;
+    if (import_lodash.default.isObjectLike(object)) {
+      Object.keys(object).forEach(function(key) {
+        var _a;
+        const value = object[key];
+        const isarray = opts.safe && Array.isArray(value);
+        const type = Object.prototype.toString.call(value);
+        const isbuffer = isBuffer(value);
+        const isobject = type === "[object Object]" || type === "[object Array]";
+        const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+        if ((_a = opts.breakOn) == null ? void 0 : _a.call(opts, { key, value, path: newKey })) {
+          output[newKey] = transformValue(value, newKey);
+          return;
+        }
+        if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) {
+          return step(value, newKey, currentDepth + 1);
+        }
+        output[newKey] = transformValue(value, newKey);
+      });
+    }
+  }
+  __name(step, "step");
+  step(target);
+  return output;
+}
+__name(flatten, "flatten");
+function unflatten(obj, opts = {}) {
+  const parsed = {};
+  const transformValue = opts.transformValue || keyIdentity;
+  for (const key of Object.keys(obj)) {
+    (0, import_set.default)(parsed, key, transformValue(obj[key], key));
+  }
+  return parsed;
+}
+__name(unflatten, "unflatten");
+const parsePath = /* @__PURE__ */ __name((path) => {
+  let operator = path.split(".").pop() || "";
+  if (!operator.startsWith("$")) {
+    operator = "";
+  }
+  return { operator };
+}, "parsePath");
+const isDateOperator = /* @__PURE__ */ __name((op) => {
+  return [
+    "$dateOn",
+    "$dateNotOn",
+    "$dateBefore",
+    "$dateAfter",
+    "$dateNotBefore",
+    "$dateNotAfter",
+    "$dateBetween"
+  ].includes(op);
+}, "isDateOperator");
+function isDate(input) {
+  return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]";
+}
+__name(isDate, "isDate");
+const dateValueWrapper = /* @__PURE__ */ __name((value, timezone) => {
+  if (!value) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 2) {
+      value.push("[]", timezone);
+    } else if (value.length === 3) {
+      value.push(timezone);
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    if (!timezone || /(\+|-)\d\d:\d\d$/.test(value)) {
+      return value;
+    }
+    return value + timezone;
+  }
+  if (isDate(value)) {
+    return value.toISOString();
+  }
+}, "dateValueWrapper");
+const parseFilter = /* @__PURE__ */ __name(async (filter, opts = {}) => {
+  const userFieldsSet = /* @__PURE__ */ new Set();
+  const vars = opts.vars || {};
+  const timezone = opts.timezone;
+  const now = opts.now;
+  const getField = opts.getField;
+  const flat = flatten(filter, {
+    breakOn({ key }) {
+      return key.startsWith("$") && key !== "$and" && key !== "$or";
+    },
+    transformValue(value) {
+      if (typeof value !== "string") {
+        return value;
+      }
+      const match = re.exec(value);
+      if (match) {
+        const key = match[1].trim();
+        if (key.startsWith("$user")) {
+          userFieldsSet.add(key.substring(6));
+        }
+      }
+      return value;
+    }
+  });
+  if (userFieldsSet.size > 0) {
+    const $user = await vars.$user({ fields: [...userFieldsSet.values()] });
+    Object.assign(vars, { $user });
+  }
+  return unflatten(flat, {
+    transformValue(value, path) {
+      const { operator } = parsePath(path);
+      if (typeof value === "string") {
+        const match = re.exec(value);
+        if (match) {
+          const key = match[1].trim();
+          const val = (0, import_getValuesByPath.getValuesByPath)(vars, key, null);
+          const field = getField == null ? void 0 : getField(path);
+          value = typeof val === "function" ? val == null ? void 0 : val({ field, operator, timezone, now }) : val;
+        }
+      }
+      if (isDateOperator(operator)) {
+        const field = getField == null ? void 0 : getField(path);
+        if ((field == null ? void 0 : field.constructor.name) === "DateOnlyField" || (field == null ? void 0 : field.constructor.name) === "DatetimeNoTzField") {
+          return value;
+        }
+        return dateValueWrapper(value, (field == null ? void 0 : field.timezone) || timezone);
+      }
+      return value;
+    }
+  });
+}, "parseFilter");
+function getDayRange(options) {
+  const { now, timezone = "+00:00", offset } = options;
+  let m = toMoment(now).utcOffset((0, import_date.offsetFromString)(timezone));
+  if (offset > 0) {
+    return [
+      // 第二天开始计算
+      (m = m.add(1, "day").startOf("day")).format("YYYY-MM-DD"),
+      // 第九天开始前结束
+      m.clone().add(offset, "day").startOf("day").format("YYYY-MM-DD"),
+      "[)",
+      timezone
+    ];
+  }
+  return [
+    // 今天开始前
+    m.clone().subtract(-1 * offset - 1, "day").startOf("day").format("YYYY-MM-DD"),
+    // 明天开始前
+    m.clone().add(1, "day").startOf("day").format("YYYY-MM-DD"),
+    "[)",
+    timezone
+  ];
+}
+__name(getDayRange, "getDayRange");
+function toMoment(value, useMoment = false) {
+  if (!value) {
+    return useMoment ? (0, import_moment.default)() : (0, import_dayjs.dayjs)();
+  }
+  if (import_dayjs.dayjs.isDayjs(value)) {
+    return value;
+  }
+  return useMoment ? (0, import_moment.default)(value) : (0, import_dayjs.dayjs)(value);
+}
+__name(toMoment, "toMoment");
+function utc2unit(options) {
+  var _a;
+  const { now, unit, timezone = "+00:00", offset } = options;
+  let m = toMoment(now, unit === "isoWeek");
+  m = m.utcOffset((0, import_date.offsetFromString)(timezone));
+  m = m.startOf(unit);
+  if (offset > 0) {
+    m = m.add(offset, unit);
+  } else if (offset < 0) {
+    m = m.subtract(-1 * offset, unit);
+  }
+  const fn = {
+    year: /* @__PURE__ */ __name(() => m.format("YYYY"), "year"),
+    quarter: /* @__PURE__ */ __name(() => m.format("YYYY[Q]Q"), "quarter"),
+    month: /* @__PURE__ */ __name(() => m.format("YYYY-MM"), "month"),
+    week: /* @__PURE__ */ __name(() => m.format("gggg[w]ww"), "week"),
+    isoWeek: /* @__PURE__ */ __name(() => m.format("GGGG[W]WW"), "isoWeek"),
+    day: /* @__PURE__ */ __name(() => m.format("YYYY-MM-DD"), "day")
+  };
+  const r = (_a = fn[unit]) == null ? void 0 : _a.call(fn);
+  return timezone ? r + timezone : r;
+}
+__name(utc2unit, "utc2unit");
+const toUnit = /* @__PURE__ */ __name((unit, offset) => {
+  return ({ now, timezone, field }) => {
+    if (field == null ? void 0 : field.timezone) {
+      timezone = field == null ? void 0 : field.timezone;
+    }
+    return utc2unit({ now, timezone, unit, offset });
+  };
+}, "toUnit");
+const toDays = /* @__PURE__ */ __name((offset) => {
+  return ({ now, timezone, field }) => {
+    if (field == null ? void 0 : field.timezone) {
+      timezone = field == null ? void 0 : field.timezone;
+    }
+    return getDayRange({ now, timezone, offset });
+  };
+}, "toDays");
+function getDateVars() {
+  return {
+    now: (/* @__PURE__ */ new Date()).toISOString(),
+    today: toUnit("day"),
+    yesterday: toUnit("day", -1),
+    tomorrow: toUnit("day", 1),
+    thisWeek: toUnit("week"),
+    lastWeek: toUnit("week", -1),
+    nextWeek: toUnit("week", 1),
+    thisIsoWeek: toUnit("isoWeek"),
+    lastIsoWeek: toUnit("isoWeek", -1),
+    nextIsoWeek: toUnit("isoWeek", 1),
+    thisMonth: toUnit("month"),
+    lastMonth: toUnit("month", -1),
+    nextMonth: toUnit("month", 1),
+    thisQuarter: toUnit("quarter"),
+    lastQuarter: toUnit("quarter", -1),
+    nextQuarter: toUnit("quarter", 1),
+    thisYear: toUnit("year"),
+    lastYear: toUnit("year", -1),
+    nextYear: toUnit("year", 1),
+    last7Days: toDays(-7),
+    next7Days: toDays(7),
+    last30Days: toDays(-30),
+    next30Days: toDays(30),
+    last90Days: toDays(-90),
+    next90Days: toDays(90)
+  };
+}
+__name(getDateVars, "getDateVars");
+function splitPathToTwoParts(path) {
+  const parts = path.split(".");
+  return [parts.shift(), parts.join(".")];
+}
+__name(splitPathToTwoParts, "splitPathToTwoParts");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flatten,
+  getDateVars,
+  getDayRange,
+  parseFilter,
+  splitPathToTwoParts,
+  toUnit,
+  unflatten,
+  utc2unit
+});

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/lib/parseHTML.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+/**
+ * parseHTML('<span>{{version}}</span>', { version: '1.0.0' }) -> '<span>1.0.0</span>'
+ * @param html
+ * @param variables
+ * @returns
+ */
+export declare function parseHTML(html: string, variables: Record<string, any>): string;