@tachybase/utils 0.23.8

package/lib/common.js

@@ -0,0 +1,98 @@
+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 common_exports = {};
+__export(common_exports, {
+  fuzzysearch: () => fuzzysearch,
+  hasEmptyValue: () => hasEmptyValue,
+  isArray: () => isArray,
+  isEmpty: () => isEmpty,
+  isPlainObject: () => isPlainObject,
+  isString: () => isString,
+  nextTick: () => nextTick
+});
+module.exports = __toCommonJS(common_exports);
+const isString = /* @__PURE__ */ __name((value) => {
+  return typeof value === "string";
+}, "isString");
+const isArray = /* @__PURE__ */ __name((value) => {
+  return Array.isArray(value);
+}, "isArray");
+const isEmpty = /* @__PURE__ */ __name((value) => {
+  if (isPlainObject(value)) {
+    return Object.keys(value).length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  return !value;
+}, "isEmpty");
+const isPlainObject = /* @__PURE__ */ __name((value) => {
+  if (Object.prototype.toString.call(value) !== "[object Object]") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}, "isPlainObject");
+const hasEmptyValue = /* @__PURE__ */ __name((objOrArr) => {
+  let result = true;
+  for (const key in objOrArr) {
+    result = false;
+    if (isArray(objOrArr[key]) && objOrArr[key].length === 0) {
+      return true;
+    }
+    if (!objOrArr[key]) {
+      return true;
+    }
+    if (isPlainObject(objOrArr[key]) || isArray(objOrArr[key])) {
+      return hasEmptyValue(objOrArr[key]);
+    }
+  }
+  return result;
+}, "hasEmptyValue");
+const nextTick = /* @__PURE__ */ __name((fn) => {
+  setTimeout(fn);
+}, "nextTick");
+function fuzzysearch(needle, haystack) {
+  const hlen = haystack.length;
+  const nlen = needle.length;
+  if (nlen === hlen) {
+    return needle === haystack;
+  }
+  outer: for (let i = 0, j = 0; i < nlen; i++) {
+    const nch = needle.charCodeAt(i);
+    while (j < hlen) {
+      if (haystack.charCodeAt(j++) === nch) {
+        continue outer;
+      }
+    }
+    return false;
+  }
+  return true;
+}
+__name(fuzzysearch, "fuzzysearch");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fuzzysearch,
+  hasEmptyValue,
+  isArray,
+  isEmpty,
+  isPlainObject,
+  isString,
+  nextTick
+});

package/lib/currencyUtils.d.ts

@@ -0,0 +1,44 @@
+export declare enum FormatType {
+    /**
+     * 金额
+     */
+    currency = "currency",
+    /**
+     * 百分比
+     */
+    percent = "percent",
+    /**
+     * 数量
+     */
+    quantity = "quantity"
+}
+/**
+ * 格式化数字，支持金额、百分比、数量等
+ * @param _number 数字
+ * @param fractionDigits 保留位数
+ * @param formatType 格式化类型: 'currency' | 'percent' | 'quantity' / 金额，百分比，数量
+ * @returns 格式化后的字符串
+ */
+declare const format: (_number: number, fractionDigits: number, formatType: FormatType) => string;
+/**
+ * 计算金额
+ * @param number 金额
+ * @param fractionDigits 需要保留的位数
+ * @returns
+ */
+export declare const formatCurrency: (number: number, fractionDigits: number) => string;
+/**
+ *计算百分比
+ * @param number 需要转化的百分比
+ * @param fractionDigits 保留位数
+ * @returns
+ */
+export declare const formatPercent: (number: number, fractionDigits: number) => string;
+/**
+ * 计算数量
+ * @param number 数字
+ * @param fractionDigits  需要保留的位数
+ * @returns
+ */
+export declare const formatQuantity: (number: number, fractionDigits?: number) => string;
+export default format;

package/lib/currencyUtils.js

@@ -0,0 +1,75 @@
+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 currencyUtils_exports = {};
+__export(currencyUtils_exports, {
+  FormatType: () => FormatType,
+  default: () => currencyUtils_default,
+  formatCurrency: () => formatCurrency,
+  formatPercent: () => formatPercent,
+  formatQuantity: () => formatQuantity
+});
+module.exports = __toCommonJS(currencyUtils_exports);
+var FormatType = /* @__PURE__ */ ((FormatType2) => {
+  FormatType2["currency"] = "currency";
+  FormatType2["percent"] = "percent";
+  FormatType2["quantity"] = "quantity";
+  return FormatType2;
+})(FormatType || {});
+const format = /* @__PURE__ */ __name((_number, fractionDigits, formatType) => {
+  const number = typeof _number === "undefined" || Number.isNaN(_number) ? 0 : _number;
+  let style;
+  let currency;
+  switch (formatType) {
+    case "currency":
+      style = "currency";
+      currency = "CNY";
+      break;
+    case "percent":
+      style = "percent";
+      break;
+    case "quantity":
+      style = "decimal";
+      break;
+    default:
+      throw new Error('Invalid formatType. Supported values are "currency", "percent", and "quantity".');
+  }
+  const options = {
+    style,
+    currency,
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits
+  };
+  const numberFormat = new Intl.NumberFormat("zh-CN", options);
+  return numberFormat.format(number);
+}, "format");
+const formatCurrency = /* @__PURE__ */ __name((number, fractionDigits) => format(number, fractionDigits, "currency" /* currency */), "formatCurrency");
+const formatPercent = /* @__PURE__ */ __name((number, fractionDigits) => format(number, fractionDigits, "percent" /* percent */), "formatPercent");
+const formatQuantity = /* @__PURE__ */ __name((number, fractionDigits = 2) => format(number, fractionDigits, "quantity" /* quantity */), "formatQuantity");
+var currencyUtils_default = format;
+function _isDecimal(num) {
+  return Number.isFinite(num) && !Number.isInteger(num);
+}
+__name(_isDecimal, "_isDecimal");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormatType,
+  formatCurrency,
+  formatPercent,
+  formatQuantity
+});

package/lib/date.d.ts

@@ -0,0 +1,22 @@
+import { dayjs } from './dayjs';
+export interface Str2momentOptions {
+    gmt?: boolean;
+    picker?: 'year' | 'month' | 'week' | 'quarter';
+    utcOffset?: any;
+    utc?: boolean;
+}
+export declare const getDefaultFormat: (props: any) => any;
+export declare const toGmt: (value: dayjs.Dayjs) => string | dayjs.Dayjs;
+export declare const toLocal: (value: dayjs.Dayjs) => string | any[] | dayjs.Dayjs;
+export declare const convertUTCToLocal: (utcString: any, formater?: string) => string;
+export declare const str2moment: (value?: string | string[], options?: Str2momentOptions) => any;
+export interface Moment2strOptions {
+    showTime?: boolean;
+    gmt?: boolean;
+    picker?: 'year' | 'month' | 'week' | 'quarter';
+}
+export declare const moment2str: (value?: dayjs.Dayjs, options?: Moment2strOptions) => string | any[] | dayjs.Dayjs;
+/**
+ * from https://github.com/moment/moment/blob/dca02edaeceda3fcd52b20b51c130631a058a022/src/lib/units/offset.js#L55-L70
+ */
+export declare function offsetFromString(string: string | number): number;

package/lib/date.js

@@ -0,0 +1,186 @@
+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 date_exports = {};
+__export(date_exports, {
+  convertUTCToLocal: () => convertUTCToLocal,
+  getDefaultFormat: () => getDefaultFormat,
+  moment2str: () => moment2str,
+  offsetFromString: () => offsetFromString,
+  str2moment: () => str2moment,
+  toGmt: () => toGmt,
+  toLocal: () => toLocal
+});
+module.exports = __toCommonJS(date_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_dayjs = require("./dayjs");
+const getDefaultFormat = /* @__PURE__ */ __name((props) => {
+  if (props.format) {
+    return props.format;
+  }
+  if (props.dateFormat) {
+    if (props["showTime"]) {
+      return `${props.dateFormat} ${props.timeFormat || "HH:mm:ss"}`;
+    }
+    return props.dateFormat;
+  }
+  if (props["picker"] === "month") {
+    return "YYYY-MM";
+  } else if (props["picker"] === "quarter") {
+    return "YYYY-\\QQ";
+  } else if (props["picker"] === "year") {
+    return "YYYY";
+  } else if (props["picker"] === "week") {
+    return "YYYY-wo";
+  }
+  return props["showTime"] ? "YYYY-MM-DD HH:mm:ss" : "YYYY-MM-DD";
+}, "getDefaultFormat");
+const toGmt = /* @__PURE__ */ __name((value) => {
+  if (!value || !import_dayjs.dayjs.isDayjs(value)) {
+    return value;
+  }
+  return `${value.format("YYYY-MM-DD")}T${value.format("HH:mm:ss.SSS")}Z`;
+}, "toGmt");
+const toLocal = /* @__PURE__ */ __name((value) => {
+  if (!value) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((val) => val.startOf("second").toISOString());
+  }
+  if (import_dayjs.dayjs.isDayjs(value)) {
+    return value.startOf("second").toISOString();
+  }
+}, "toLocal");
+const convertUTCToLocal = /* @__PURE__ */ __name((utcString, formater = "YYYY-MM-DD HH:mm:ss") => {
+  const localDate = import_dayjs.dayjs.utc(utcString).local().format(formater);
+  return localDate;
+}, "convertUTCToLocal");
+const toMoment = /* @__PURE__ */ __name((val, options) => {
+  if (!val) {
+    return;
+  }
+  const offset = options.utcOffset || -1 * (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  const { gmt, picker, utc = true } = options;
+  if (!utc) {
+    return (0, import_dayjs.dayjs)(val);
+  }
+  if (import_dayjs.dayjs.isDayjs(val)) {
+    return val.utcOffset(offsetFromString(offset));
+  }
+  if (gmt || picker) {
+    return (0, import_dayjs.dayjs)(val).utcOffset(0);
+  }
+  return (0, import_dayjs.dayjs)(val).utcOffset(offsetFromString(offset));
+}, "toMoment");
+const str2moment = /* @__PURE__ */ __name((value, options = {}) => {
+  return Array.isArray(value) ? value.map((val) => {
+    return toMoment(val, options);
+  }) : value ? toMoment(value, options) : value;
+}, "str2moment");
+const toStringByPicker = /* @__PURE__ */ __name((value, picker) => {
+  if (picker === "year") {
+    return value.format("YYYY") + "-01-01T00:00:00.000Z";
+  }
+  if (picker === "month") {
+    return value.format("YYYY-MM") + "-01T00:00:00.000Z";
+  }
+  if (picker === "quarter") {
+    return value.format("YYYY-MM") + "-01T00:00:00.000Z";
+  }
+  if (picker === "week") {
+    return value.format("YYYY-MM-DD") + "T00:00:00.000Z";
+  }
+  return value.format("YYYY-MM-DD") + "T00:00:00.000Z";
+}, "toStringByPicker");
+const toGmtByPicker = /* @__PURE__ */ __name((value, picker) => {
+  if (!value) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((val) => toStringByPicker(val, picker));
+  }
+  if (import_dayjs.dayjs.isDayjs(value)) {
+    return toStringByPicker(value, picker);
+  }
+}, "toGmtByPicker");
+const moment2str = /* @__PURE__ */ __name((value, options = {}) => {
+  const { showTime, gmt, picker } = options;
+  if (!value) {
+    return value;
+  }
+  if (showTime) {
+    return gmt ? toGmt(value) : toLocal(value);
+  }
+  return toGmtByPicker(value, picker);
+}, "moment2str");
+function offsetFromString(string) {
+  if (!import_lodash.default.isString(string)) {
+    return string;
+  }
+  const chunkOffset = /([+-]|\d\d)/gi;
+  const matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, matchTimestamp = /[+-]?\d+(\.\d{1,3})?/;
+  let matches = (string || "").match(matchShortOffset);
+  if (matches === null) {
+    matches = (string || "").match(matchTimestamp);
+  }
+  if (matches === null) {
+    return null;
+  }
+  const chunk = matches[matches.length - 1] || [];
+  const parts = (chunk + "").match(chunkOffset) || ["-", 0, 0];
+  const minutes = +(Number(parts[1]) * 60) + toInt(parts[2]);
+  return minutes === 0 ? 0 : parts[0] === "+" ? minutes : -minutes;
+}
+__name(offsetFromString, "offsetFromString");
+function toInt(argumentForCoercion) {
+  let coercedNumber = +argumentForCoercion, value = 0;
+  if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+    value = absFloor(coercedNumber);
+  }
+  return value;
+}
+__name(toInt, "toInt");
+function absFloor(number) {
+  if (number < 0) {
+    return Math.ceil(number) || 0;
+  } else {
+    return Math.floor(number);
+  }
+}
+__name(absFloor, "absFloor");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertUTCToLocal,
+  getDefaultFormat,
+  moment2str,
+  offsetFromString,
+  str2moment,
+  toGmt,
+  toLocal
+});

package/lib/dayjs.d.ts

@@ -0,0 +1,10 @@
+import dayjs, { type Dayjs } from 'dayjs';
+import 'dayjs/plugin/isBetween';
+import 'dayjs/plugin/isSameOrAfter';
+import 'dayjs/plugin/isSameOrBefore';
+import 'dayjs/plugin/isoWeek';
+import 'dayjs/plugin/localeData';
+import 'dayjs/plugin/quarterOfYear';
+import 'dayjs/plugin/utc';
+import 'dayjs/plugin/weekday';
+export { dayjs, Dayjs };

package/lib/dayjs.js

@@ -0,0 +1,73 @@
+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 __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 dayjs_exports = {};
+__export(dayjs_exports, {
+  dayjs: () => import_dayjs.default
+});
+module.exports = __toCommonJS(dayjs_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_advancedFormat = __toESM(require("dayjs/plugin/advancedFormat"));
+var import_calendar = __toESM(require("dayjs/plugin/calendar"));
+var import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat"));
+var import_isBetween = __toESM(require("dayjs/plugin/isBetween"));
+var import_isoWeek = __toESM(require("dayjs/plugin/isoWeek"));
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"));
+var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore"));
+var import_localeData = __toESM(require("dayjs/plugin/localeData"));
+var import_quarterOfYear = __toESM(require("dayjs/plugin/quarterOfYear"));
+var import_timezone = __toESM(require("dayjs/plugin/timezone"));
+var import_utc = __toESM(require("dayjs/plugin/utc"));
+var import_weekday = __toESM(require("dayjs/plugin/weekday"));
+var import_weekOfYear = __toESM(require("dayjs/plugin/weekOfYear"));
+var import_weekYear = __toESM(require("dayjs/plugin/weekYear"));
+var import_isBetween2 = require("dayjs/plugin/isBetween");
+var import_isSameOrAfter2 = require("dayjs/plugin/isSameOrAfter");
+var import_isSameOrBefore2 = require("dayjs/plugin/isSameOrBefore");
+var import_isoWeek2 = require("dayjs/plugin/isoWeek");
+var import_localeData2 = require("dayjs/plugin/localeData");
+var import_quarterOfYear2 = require("dayjs/plugin/quarterOfYear");
+var import_utc2 = require("dayjs/plugin/utc");
+var import_weekday2 = require("dayjs/plugin/weekday");
+import_dayjs.default.extend(import_weekday.default);
+import_dayjs.default.extend(import_localeData.default);
+import_dayjs.default.extend(import_timezone.default);
+import_dayjs.default.extend(import_utc.default);
+import_dayjs.default.extend(import_quarterOfYear.default);
+import_dayjs.default.extend(import_isoWeek.default);
+import_dayjs.default.extend(import_isBetween.default);
+import_dayjs.default.extend(import_isSameOrAfter.default);
+import_dayjs.default.extend(import_isSameOrBefore.default);
+import_dayjs.default.extend(import_weekOfYear.default);
+import_dayjs.default.extend(import_weekYear.default);
+import_dayjs.default.extend(import_customParseFormat.default);
+import_dayjs.default.extend(import_advancedFormat.default);
+import_dayjs.default.extend(import_calendar.default);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dayjs
+});

package/lib/decorators.d.ts

@@ -0,0 +1,16 @@
+export interface ActionDef {
+    type: string;
+    resourceName?: string;
+    actionName?: string;
+    method?: string;
+    options?: {
+        acl?: string;
+    };
+}
+export declare function App(): Function;
+export declare function Db(): Function;
+export declare function InjectLog(): Function;
+export declare function Controller(name: string): (target: any, context: ClassDecoratorContext) => void;
+export declare function Action(name: string, options?: {
+    acl?: string;
+}): (_: any, context: ClassMethodDecoratorContext) => void;

package/lib/decorators.js

@@ -0,0 +1,94 @@
+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 decorators_exports = {};
+__export(decorators_exports, {
+  Action: () => Action,
+  App: () => App,
+  Controller: () => Controller,
+  Db: () => Db,
+  InjectLog: () => InjectLog
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_typedi = __toESM(require("./typedi"));
+import_typedi.default.set({ id: "actions", value: /* @__PURE__ */ new Map() });
+function App() {
+  return (0, import_typedi.Inject)("app");
+}
+__name(App, "App");
+function Db() {
+  return (0, import_typedi.Inject)("db");
+}
+__name(Db, "Db");
+function InjectLog() {
+  return (0, import_typedi.Inject)("logger");
+}
+__name(InjectLog, "InjectLog");
+function Controller(name) {
+  return function(target, context) {
+    const serviceOptions = { id: "controller", multiple: true };
+    (0, import_typedi.Service)(serviceOptions)(target, context);
+    const actions = import_typedi.default.get("actions");
+    if (!actions.has(target)) {
+      actions.set(target, []);
+    }
+    actions.get(target).push({
+      type: "resource",
+      resourceName: name
+    });
+  };
+}
+__name(Controller, "Controller");
+function Action(name, options) {
+  return function(_, context) {
+    if (!context.metadata.injects) {
+      context.metadata.injects = [];
+    }
+    context.metadata.injects.push((target) => {
+      const actions = import_typedi.default.get("actions");
+      if (!actions.has(target)) {
+        actions.set(target, []);
+      }
+      actions.get(target).push({
+        type: "action",
+        method: String(context.name),
+        actionName: name,
+        options
+      });
+    });
+  };
+}
+__name(Action, "Action");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Action,
+  App,
+  Controller,
+  Db,
+  InjectLog
+});

package/lib/dom.d.ts

@@ -0,0 +1,4 @@
+export declare const canUseDom: boolean;
+type ScrollElement = HTMLElement | Window;
+export declare function getScrollParent(el: Element, root?: ScrollElement | null | undefined): Window | Element | null | undefined;
+export {};

package/lib/dom.js

@@ -0,0 +1,52 @@
+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 dom_exports = {};
+__export(dom_exports, {
+  canUseDom: () => canUseDom,
+  getScrollParent: () => getScrollParent
+});
+module.exports = __toCommonJS(dom_exports);
+const canUseDom = !!(typeof window !== "undefined" && typeof document !== "undefined" && window.document && window.document.createElement);
+const defaultRoot = canUseDom ? window : void 0;
+const overflowStylePatterns = ["scroll", "auto", "overlay"];
+function isElement(node) {
+  const ELEMENT_NODE_TYPE = 1;
+  return node.nodeType === ELEMENT_NODE_TYPE;
+}
+__name(isElement, "isElement");
+function getScrollParent(el, root = defaultRoot) {
+  let node = el;
+  while (node && node !== root && isElement(node)) {
+    if (node === document.body) {
+      return root;
+    }
+    const { overflowY } = window.getComputedStyle(node);
+    if (overflowStylePatterns.includes(overflowY) && node.scrollHeight > node.clientHeight) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return root;
+}
+__name(getScrollParent, "getScrollParent");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  canUseDom,
+  getScrollParent
+});

package/lib/forEach.d.ts

@@ -0,0 +1 @@
+export declare const forEach: (obj: any, callback: (value: any, key: string | number) => void) => void;