@tachybase/utils 0.23.8

package/lib/typedi/interfaces/handler.interface.d.ts

@@ -0,0 +1,27 @@
+import { ContainerInstance } from '../container-instance.class';
+import { Constructable } from '../types/constructable.type';
+/**
+ * Used to register special "handler" which will be executed on a service class during its initialization.
+ * It can be used to create custom decorators and set/replace service class properties and constructor parameters.
+ */
+export interface Handler<T = unknown> {
+    /**
+     * Service object used to apply handler to.
+     */
+    object: Constructable<T>;
+    /**
+     * Class property name to set/replace value of.
+     * Used if handler is applied on a class property.
+     */
+    propertyName?: string;
+    /**
+     * Parameter index to set/replace value of.
+     * Used if handler is applied on a constructor parameter.
+     */
+    index?: number;
+    /**
+     * Factory function that produces value that will be set to class property or constructor parameter.
+     * Accepts container instance which requested the value.
+     */
+    value: (container: ContainerInstance) => any;
+}

package/lib/typedi/interfaces/handler.interface.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 handler_interface_exports = {};
+module.exports = __toCommonJS(handler_interface_exports);

package/lib/typedi/interfaces/service-metadata.interface.d.ts

@@ -0,0 +1,53 @@
+import { ContainerInstance } from '../container-instance.class';
+import { Constructable } from '../types/constructable.type';
+import { ContainerIdentifier } from '../types/container-identifier.type';
+import { ContainerScope } from '../types/container-scope.type';
+import { ServiceIdentifier } from '../types/service-identifier.type';
+/**
+ * Service metadata is used to initialize service and store its state.
+ */
+export interface ServiceMetadata<Type = unknown> {
+    /** Unique identifier of the referenced service. */
+    id: ServiceIdentifier;
+    /**
+     * The injection scope for the service.
+     *   - a `singleton` service always will be created in the default container regardless of who registering it
+     *   - a `container` scoped service will be created once when requested from the given container
+     *   - a `transient` service will be created each time it is requested
+     */
+    scope: ContainerScope;
+    /**
+     * Class definition of the service what is used to initialize given service.
+     * This property maybe null if the value of the service is set manually.
+     * If id is not set then it serves as service id.
+     */
+    type: Constructable<Type> | null;
+    /**
+     * Factory function used to initialize this service.
+     * Can be regular function ("createCar" for example),
+     * or other service which produces this instance ([CarFactory, "createCar"] for example).
+     */
+    factory: [Constructable<unknown>, string] | CallableFunction | undefined;
+    /**
+     * Instance of the target class.
+     */
+    value: unknown | Symbol;
+    /**
+     * Allows to setup multiple instances the different classes under a single service id string or token.
+     */
+    multiple: boolean;
+    /**
+     * Indicates whether a new instance should be created as soon as the class is registered.
+     * By default the registered classes are only instantiated when they are requested from the container.
+     *
+     * _Note: This option is ignored for transient services._
+     */
+    eager: boolean;
+    /**
+     * Map of containers referencing this metadata. This is used when a container
+     * is inheriting it's parents definitions and values to track the lifecycle of
+     * the metadata. Namely, a service can be disposed only if it's only referenced
+     * by the container being disposed.
+     */
+    referencedBy: Map<ContainerIdentifier, ContainerInstance>;
+}

package/lib/typedi/interfaces/service-metadata.interface.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 service_metadata_interface_exports = {};
+module.exports = __toCommonJS(service_metadata_interface_exports);

package/lib/typedi/interfaces/service-options.interface.d.ts

@@ -0,0 +1,6 @@
+import { ServiceMetadata } from './service-metadata.interface';
+/**
+ * The public ServiceOptions is partial object of ServiceMetadata and either one
+ * of the following is set: `type`, `factory`, `value` but not more than one.
+ */
+export type ServiceOptions<T = unknown> = Omit<Partial<ServiceMetadata<T>>, 'referencedBy' | 'type' | 'factory'> | Omit<Partial<ServiceMetadata<T>>, 'referencedBy' | 'value' | 'factory'> | Omit<Partial<ServiceMetadata<T>>, 'referencedBy' | 'value' | 'type'>;

package/lib/typedi/interfaces/service-options.interface.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 service_options_interface_exports = {};
+module.exports = __toCommonJS(service_options_interface_exports);

package/lib/typedi/token.class.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Used to create unique typed service identifier.
+ * Useful when service has only interface, but don't have a class.
+ */
+export declare class Token<T> {
+    name?: string;
+    /**
+     * @param name Token name, optional and only used for debugging purposes.
+     */
+    constructor(name?: string);
+}

package/lib/typedi/token.class.js

@@ -0,0 +1,37 @@
+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 token_class_exports = {};
+__export(token_class_exports, {
+  Token: () => Token
+});
+module.exports = __toCommonJS(token_class_exports);
+const _Token = class _Token {
+  /**
+   * @param name Token name, optional and only used for debugging purposes.
+   */
+  constructor(name) {
+    this.name = name;
+  }
+};
+__name(_Token, "Token");
+let Token = _Token;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Token
+});

package/lib/typedi/types/abstract-constructable.type.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generic type for abstract class definitions.
+ *
+ * Explanation: This describes a newable Function with a prototype Which is
+ * what an abstract class is - no constructor, just the prototype.
+ */
+export type AbstractConstructable<T> = NewableFunction & {
+    prototype: T;
+};

package/lib/typedi/types/abstract-constructable.type.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 abstract_constructable_type_exports = {};
+module.exports = __toCommonJS(abstract_constructable_type_exports);

package/lib/typedi/types/constructable.type.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generic type for class definitions.
+ * Example usage:
+ * ```
+ * function createSomeInstance(myClassDefinition: Constructable<MyClass>) {
+ *   return new myClassDefinition()
+ * }
+ * ```
+ */
+export type Constructable<T> = new (...args: any[]) => T;

package/lib/typedi/types/constructable.type.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 constructable_type_exports = {};
+module.exports = __toCommonJS(constructable_type_exports);

package/lib/typedi/types/container-identifier.type.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A container identifier. This value must be unique across all containers.
+ */
+export type ContainerIdentifier = string | Symbol;

package/lib/typedi/types/container-identifier.type.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 container_identifier_type_exports = {};
+module.exports = __toCommonJS(container_identifier_type_exports);

package/lib/typedi/types/container-scope.type.d.ts

@@ -0,0 +1 @@
+export type ContainerScope = 'singleton' | 'container' | 'transient';

package/lib/typedi/types/container-scope.type.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 container_scope_type_exports = {};
+module.exports = __toCommonJS(container_scope_type_exports);

package/lib/typedi/types/service-identifier.type.d.ts

@@ -0,0 +1,8 @@
+import { Token } from '../token.class';
+import { AbstractConstructable } from './abstract-constructable.type';
+import { Constructable } from './constructable.type';
+/**
+ * Unique service identifier.
+ * Can be some class type, or string id, or instance of Token.
+ */
+export type ServiceIdentifier<T = unknown> = Constructable<T> | AbstractConstructable<T> | CallableFunction | Token<T> | string;

package/lib/typedi/types/service-identifier.type.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 service_identifier_type_exports = {};
+module.exports = __toCommonJS(service_identifier_type_exports);

package/lib/typedi/utils/resolve-to-type-wrapper.util.d.ts

@@ -0,0 +1,15 @@
+import { Constructable } from '../types/constructable.type';
+import { ServiceIdentifier } from '../types/service-identifier.type';
+/**
+ * Helper function used in inject decorators to resolve the received identifier to
+ * an eager type when possible or to a lazy type when cyclic dependencies are possibly involved.
+ *
+ * @param typeOrIdentifier a service identifier or a function returning a type acting as service identifier or nothing
+ * @param target the class definition of the target of the decorator
+ * @param propertyName the name of the property in case of a PropertyDecorator
+ * @param index the index of the parameter in the constructor in case of ParameterDecorator
+ */
+export declare function resolveToTypeWrapper(typeOrIdentifier: ((type?: never) => Constructable<unknown>) | ServiceIdentifier<unknown> | undefined, target: Object, propertyName: string | Symbol, index?: number): {
+    eagerType: ServiceIdentifier | null;
+    lazyType: (type?: never) => ServiceIdentifier;
+};

package/lib/typedi/utils/resolve-to-type-wrapper.util.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 resolve_to_type_wrapper_util_exports = {};
+__export(resolve_to_type_wrapper_util_exports, {
+  resolveToTypeWrapper: () => resolveToTypeWrapper
+});
+module.exports = __toCommonJS(resolve_to_type_wrapper_util_exports);
+var import_token = require("../token.class");
+function resolveToTypeWrapper(typeOrIdentifier, target, propertyName, index) {
+  let typeWrapper;
+  if (typeOrIdentifier && typeof typeOrIdentifier === "string" || typeOrIdentifier instanceof import_token.Token) {
+    typeWrapper = { eagerType: typeOrIdentifier, lazyType: /* @__PURE__ */ __name(() => typeOrIdentifier, "lazyType") };
+  }
+  if (typeOrIdentifier && typeof typeOrIdentifier === "function") {
+    typeWrapper = { eagerType: null, lazyType: /* @__PURE__ */ __name(() => typeOrIdentifier(), "lazyType") };
+  }
+  return typeWrapper;
+}
+__name(resolveToTypeWrapper, "resolveToTypeWrapper");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveToTypeWrapper
+});

package/lib/uid.d.ts

@@ -0,0 +1 @@
+export declare function uid(len?: number): string;

package/lib/uid.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 uid_exports = {};
+__export(uid_exports, {
+  uid: () => uid
+});
+module.exports = __toCommonJS(uid_exports);
+let IDX = 36, HEX = "";
+while (IDX--) HEX += IDX.toString(36);
+function uid(len) {
+  let str = "", num = len || 11;
+  while (num--) str += HEX[Math.random() * 36 | 0];
+  return str;
+}
+__name(uid, "uid");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uid
+});

package/lib/url.d.ts

@@ -0,0 +1 @@
+export declare function isURL(string: any): boolean;

package/lib/url.js

@@ -0,0 +1,37 @@
+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 url_exports = {};
+__export(url_exports, {
+  isURL: () => isURL
+});
+module.exports = __toCommonJS(url_exports);
+function isURL(string) {
+  let url;
+  try {
+    url = new URL(string);
+  } catch (e) {
+    return false;
+  }
+  return url.protocol === "http:" || url.protocol === "https:";
+}
+__name(isURL, "isURL");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isURL
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@tachybase/utils",
+  "version": "0.23.8",
+  "license": "Apache-2.0",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "import": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      }
+    },
+    "./client": {
+      "require": {
+        "types": "./lib/client.d.ts",
+        "default": "./lib/client.js"
+      },
+      "import": {
+        "types": "./lib/client.d.ts",
+        "default": "./lib/client.js"
+      }
+    }
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "dependencies": {
+    "@hapi/topo": "^6.0.2",
+    "@rc-component/mini-decimal": "^1.1.0",
+    "antd": "5.22.5",
+    "dayjs": "1.11.13",
+    "dedupe": "^3.0.3",
+    "deepmerge": "^4.3.1",
+    "flat-to-nested": "^1.1.1",
+    "graphlib": "^2.1.8",
+    "lodash": "4.17.21",
+    "multer": "1.4.5-lts.1",
+    "object-path": "^0.11.8"
+  },
+  "devDependencies": {
+    "@types/lodash": "4.17.13",
+    "@types/node": "20.17.10"
+  },
+  "scripts": {
+    "build": "tachybase-build --no-dts @tachybase/utils"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "lib": ["esnext", "DOM.Iterable", "DOM"],
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "jsx": "react",
+    "target": "esnext",
+    "module": "esnext",
+    "allowJs": true,
+    "noUnusedLocals": false,
+    "preserveConstEnums": true,
+    "skipLibCheck": true,
+    "skipDefaultLibCheck": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "typeRoots": ["./node_modules/@types"],
+    "downlevelIteration": true
+  },
+  "exclude": [
+    "node_modules",
+    "lib",
+    "client.d.ts",
+    "server.d.ts",
+    "client.js",
+    "server.js",
+    "plugin-symlink.d.ts",
+    "plugin-symlink.js"
+  ]
+}