taon 21.0.52 → 21.0.53

package/lib-prod/helpers/class-helpers.js

@@ -0,0 +1,195 @@
+import * as FormData from "form-data";
+import { ___NS__isArray, ___NS__isArrayBuffer, ___NS__isBuffer, ___NS__isDate, ___NS__isFunction, ___NS__isNull, ___NS__isObject, ___NS__isRegExp, ___NS__isString, ___NS__isUndefined, ___NS__uniq, Utils__NS__uniqArray } from "tnp-core/lib-prod";
+import { CLASS } from "typescript-class-helpers/lib-prod";
+import {
+  controllerConfigFrom
+} from "../config/controller-config";
+import { Symbols__NS__classNameStaticProperty, Symbols__NS__fullClassNameStaticProperty, Symbols__NS__metadata, Symbols__NS__orignalClass } from "../symbols";
+import { Validators__NS__classNameVlidation } from "../validators";
+const ClassHelpers__NS__getClassFnFromObject = (json) => {
+  if (___NS__isUndefined(json) || ___NS__isNull(json)) {
+    return;
+  }
+  if (json.constructor) {
+    return json.constructor;
+  }
+  const p = Object.getPrototypeOf(json);
+  return p && p.constructor && p.constructor.name !== "Object" ? p.constructor : void 0;
+};
+const ClassHelpers__NS__getName = (classFnOrObject) => {
+  if (classFnOrObject instanceof FormData) {
+    return "FormData";
+  }
+  if (!classFnOrObject) {
+    console.error("OBJECT OR CLASS", classFnOrObject);
+    throw new Error(`Cannot get name from this object or class.`);
+  }
+  return (classFnOrObject[Symbols__NS__classNameStaticProperty] ? classFnOrObject[Symbols__NS__classNameStaticProperty] : classFnOrObject?.constructor[Symbols__NS__classNameStaticProperty]) || (___NS__isFunction(classFnOrObject) ? CLASS.getName(classFnOrObject) : void 0);
+};
+const ClassHelpers__NS__getOrginalClass = (classFnOrObject) => {
+  const org = classFnOrObject[Symbols__NS__orignalClass];
+  if (!org) {
+    return classFnOrObject;
+  }
+  return ClassHelpers__NS__getOrginalClass(org);
+};
+const ClassHelpers__NS__getFullInternalName = (classFnOrObject) => {
+  if (!classFnOrObject) {
+    throw new Error(`Cannot get name from: ${classFnOrObject}`);
+  }
+  return (classFnOrObject[Symbols__NS__fullClassNameStaticProperty] ? classFnOrObject[Symbols__NS__fullClassNameStaticProperty] : classFnOrObject?.constructor[Symbols__NS__fullClassNameStaticProperty]) || void 0;
+};
+const ClassHelpers__NS__getUniqueKey = (classFnOrObject) => {
+  const classFn = ___NS__isFunction(classFnOrObject) ? classFnOrObject : classFnOrObject.constructor;
+  const config = Reflect.getMetadata(
+    Symbols__NS__metadata.options.entity,
+    classFn
+  );
+  return config.uniqueKeyProp;
+};
+const ClassHelpers__NS__isContextClassObject = (obj) => {
+  if (!___NS__isObject(obj) || ___NS__isArray(obj) || ___NS__isRegExp(obj) || ___NS__isBuffer(obj) || ___NS__isArrayBuffer(obj)) {
+    return false;
+  }
+  if (___NS__isDate(obj)) {
+    return true;
+  }
+  const className = ClassHelpers__NS__getName(obj);
+  return ___NS__isString(className) && className !== "Object";
+};
+const ClassHelpers__NS__setName = (target, className) => {
+  Validators__NS__classNameVlidation(className, target);
+  target[Symbols__NS__classNameStaticProperty] = className;
+};
+const ClassHelpers__NS__hasParentClassWithName = (target, className, targets = []) => {
+  if (!target) {
+    return false;
+  }
+  targets.push(target);
+  let targetProto = Object.getPrototypeOf(target);
+  if (___NS__isFunction(targetProto) && ClassHelpers__NS__getName(targetProto) === className) {
+    return true;
+  }
+  return ClassHelpers__NS__hasParentClassWithName(targetProto, className, targets);
+};
+const notAllowedAsMethodName = [
+  "length",
+  "name",
+  "arguments",
+  "caller",
+  "constructor",
+  "apply",
+  "bind",
+  "call",
+  "toString",
+  "__defineGetter__",
+  "__defineSetter__",
+  "hasOwnProperty",
+  "__lookupGetter__",
+  "__lookupSetter__",
+  "isPrototypeOf",
+  "propertyIsEnumerable",
+  "valueOf",
+  "__proto__",
+  "toLocaleString"
+];
+const ClassHelpers__NS__asyncHandler = (fn) => (req, res, next) => {
+  Promise.resolve(fn(req, res, next)).catch(next);
+};
+const ClassHelpers__NS__getMethodsNames = (classOrClassInstance, allMethodsNames = []) => {
+  if (!classOrClassInstance) {
+    return Utils__NS__uniqArray(allMethodsNames);
+  }
+  const isClassFunction = ___NS__isFunction(classOrClassInstance);
+  const classFun = isClassFunction ? classOrClassInstance : Object.getPrototypeOf(classOrClassInstance);
+  const objectToCheck = isClassFunction ? classOrClassInstance?.prototype : classOrClassInstance;
+  const prototypeObj = Object.getPrototypeOf(objectToCheck || {});
+  const properties = ___NS__uniq([
+    ...Object.getOwnPropertyNames(objectToCheck || {}),
+    ...Object.getOwnPropertyNames(prototypeObj || {}),
+    ...Object.keys(objectToCheck || {}),
+    ...Object.keys(prototypeObj || {})
+  ]).filter((f) => !!f && !notAllowedAsMethodName.includes(f));
+  properties.filter((methodName) => typeof objectToCheck[methodName] === "function").forEach((p) => allMethodsNames.push(p));
+  if (!classFun || !classFun.constructor || classFun?.constructor?.name === "Object") {
+    return Utils__NS__uniqArray(allMethodsNames);
+  }
+  return ClassHelpers__NS__getMethodsNames(Object.getPrototypeOf(classFun), allMethodsNames);
+};
+const ClassHelpers__NS__getControllerConfigs = (target, configs = [], callerTarget) => {
+  if (!___NS__isFunction(target)) {
+    throw `[typescript-class-helper][getControllerConfigs] Cannot get class config from: ${target}`;
+  }
+  let config;
+  const parentClass = Object.getPrototypeOf(target);
+  const parentName = parentClass ? ClassHelpers__NS__getName(parentClass) : void 0;
+  const isValidParent = ___NS__isFunction(parentClass) && parentName !== "";
+  config = controllerConfigFrom(ClassHelpers__NS__getClassConfig(target));
+  configs.push(config);
+  return isValidParent ? ClassHelpers__NS__getControllerConfigs(parentClass, configs, target) : configs;
+};
+const ClassHelpers__NS__ensureClassConfig = (target) => {
+  let cfg = Reflect.getOwnMetadata(
+    Symbols__NS__metadata.options.controller,
+    // META_KEYS.class,
+    target
+  );
+  if (!cfg) {
+    cfg = { methods: {} };
+    const parent = Object.getPrototypeOf(target);
+    if (parent && parent !== Function.prototype) {
+      const parentCfg = Reflect.getMetadata(
+        Symbols__NS__metadata.options.controller,
+        // META_KEYS.class,
+        parent
+      );
+      if (parentCfg) {
+        const clonedMethods = {};
+        for (const [k, v] of Object.entries(parentCfg.methods)) {
+          clonedMethods[k] = {
+            ...v,
+            parameters: { ...v.parameters }
+            // shallow clone parameters too
+          };
+        }
+        cfg = {
+          ...parentCfg,
+          methods: clonedMethods
+        };
+      }
+    }
+    Reflect.defineMetadata(Symbols__NS__metadata.options.controller, cfg, target);
+  }
+  return cfg;
+};
+const ClassHelpers__NS__ensureMethodConfig = (target, propertyKey) => {
+  const classCfg = ClassHelpers__NS__ensureClassConfig(target.constructor);
+  let methodCfg = classCfg.methods[propertyKey?.toString()];
+  if (!methodCfg) {
+    methodCfg = { methodName: propertyKey?.toString(), parameters: {} };
+    classCfg.methods[propertyKey?.toString()] = methodCfg;
+  }
+  return methodCfg;
+};
+const ClassHelpers__NS__getClassConfig = (constructor) => {
+  return Reflect.getMetadata(
+    Symbols__NS__metadata.options.controller,
+    constructor
+  );
+};
+export {
+  ClassHelpers__NS__asyncHandler,
+  ClassHelpers__NS__ensureClassConfig,
+  ClassHelpers__NS__ensureMethodConfig,
+  ClassHelpers__NS__getClassConfig,
+  ClassHelpers__NS__getClassFnFromObject,
+  ClassHelpers__NS__getControllerConfigs,
+  ClassHelpers__NS__getFullInternalName,
+  ClassHelpers__NS__getMethodsNames,
+  ClassHelpers__NS__getName,
+  ClassHelpers__NS__getOrginalClass,
+  ClassHelpers__NS__getUniqueKey,
+  ClassHelpers__NS__hasParentClassWithName,
+  ClassHelpers__NS__isContextClassObject,
+  ClassHelpers__NS__setName
+};

package/lib-prod/helpers/clone-obj.js

@@ -0,0 +1,21 @@
+import { walk } from "lodash-walk-object/lib-prod";
+import { ___NS__cloneDeep, ___NS__isFunction, ___NS__isNil, ___NS__isObject, ___NS__merge, ___NS__set } from "tnp-core/lib-prod";
+const cloneObj = (override, classFn) => {
+  const result = ___NS__merge(new classFn(), ___NS__cloneDeep(void 0));
+  walk.Object(
+    override || {},
+    (value, lodashPath) => {
+      if (___NS__isNil(value) || ___NS__isFunction(value) || ___NS__isObject(value)) {
+      } else {
+        ___NS__set(result, lodashPath, value);
+      }
+    },
+    {
+      walkGetters: false
+    }
+  );
+  return result;
+};
+export {
+  cloneObj
+};

package/lib-prod/helpers/taon-helpers.js

@@ -0,0 +1,129 @@
+import * as JSON5 from "json5";
+import { ___NS__cloneDeep, ___NS__first, ___NS__isObject, ___NS__times } from "tnp-core/lib-prod";
+import { ClassHelpers__NS__getName } from "./class-helpers";
+const TaonHelpers__NS__fillUpTo = (s, nCharacters) => {
+  return ___NS__times(nCharacters, (n) => {
+    if (s.charAt(n)) {
+      return s.charAt(n);
+    }
+    return " ";
+  }).join("");
+};
+const TaonHelpers__NS__isGoodPath = (p) => {
+  return p && typeof p === "string" && p.trim() !== "";
+};
+const TaonHelpers__NS__firstStringOrElemFromArray = (stringOrArrayOfString) => {
+  if (Array.isArray(stringOrArrayOfString)) {
+    return ___NS__first(stringOrArrayOfString);
+  }
+  return stringOrArrayOfString;
+};
+const TaonHelpers__NS__tryTransformParam = (param) => {
+  if (typeof param === "string") {
+    let n = Number(param);
+    if (!isNaN(n)) return n;
+    const bool = param.trim().toLowerCase();
+    if (bool === "true") {
+      return true;
+    }
+    if (bool === "false") {
+      return false;
+    }
+    try {
+      const t = JSON5.parse(param);
+      return t;
+    } catch (e) {
+      return param;
+    }
+  }
+  return param;
+};
+const TaonHelpers__NS__getExpressPath = (c, pathOrClassConfig) => {
+  if (typeof pathOrClassConfig === "string")
+    return `${c.calculatedPath}${pathOrClassConfig}`.replace(/\/$/, "");
+  return `${c.calculatedPath}${pathOrClassConfig.path}`.replace(/\/$/, "");
+};
+const TaonHelpers__NS__defaultType = (value) => {
+  if (typeof value === "string") return "";
+  if (typeof value === "boolean") return false;
+  if (Array.isArray(value)) return {};
+  if (typeof value === "object") return {};
+};
+const TaonHelpers__NS__parseJSONwithStringJSONs = (object, waring = false) => {
+  if (!___NS__isObject(object)) {
+    if (waring) {
+      console.error(
+        `
+        parseJSONwithStringJSONs(...)
+        Parameter should be a object, but is ${typeof object}
+        `,
+        object
+      );
+    }
+    return object;
+  }
+  let res = ___NS__cloneDeep(object);
+  Object.keys(res).forEach((key) => {
+    let isJson = false;
+    try {
+      const possibleJSON = JSON.parse(res[key]);
+      res[key] = possibleJSON;
+      isJson = true;
+    } catch (e) {
+      isJson = false;
+    }
+    if (isJson) {
+      res[key] = TaonHelpers__NS__parseJSONwithStringJSONs(res[key], false);
+    }
+  });
+  return res;
+};
+const TaonHelpers__NS__isPlainFileOrFolder = (filePath) => {
+  return /^([a-zA-Z]|\-|\_|\@|\#|\$|\!|\^|\&|\*|\(|\))+$/.test(filePath);
+};
+const TaonHelpers__NS__ipcKeyNameResponse = (target, methodConfig, expressPath) => {
+  return [
+    "response",
+    ClassHelpers__NS__getName(target),
+    methodConfig.methodName,
+    methodConfig.type,
+    expressPath
+  ].join("--");
+};
+const TaonHelpers__NS__ipcKeyNameRequest = (target, methodConfig, expressPath) => {
+  return [
+    "request",
+    ClassHelpers__NS__getName(target),
+    methodConfig.methodName,
+    methodConfig.type,
+    expressPath
+  ].join("--");
+};
+const TaonHelpers__NS__websqlMocks = (headers) => {
+  const response = {
+    status(status) {
+      return {
+        send(send) {
+        }
+      };
+    },
+    setHeader(key, value) {
+      headers[key] = value;
+    }
+  };
+  const request = {};
+  return { request, response };
+};
+export {
+  TaonHelpers__NS__defaultType,
+  TaonHelpers__NS__fillUpTo,
+  TaonHelpers__NS__firstStringOrElemFromArray,
+  TaonHelpers__NS__getExpressPath,
+  TaonHelpers__NS__ipcKeyNameRequest,
+  TaonHelpers__NS__ipcKeyNameResponse,
+  TaonHelpers__NS__isGoodPath,
+  TaonHelpers__NS__isPlainFileOrFolder,
+  TaonHelpers__NS__parseJSONwithStringJSONs,
+  TaonHelpers__NS__tryTransformParam,
+  TaonHelpers__NS__websqlMocks
+};

package/lib-prod/index.js

@@ -0,0 +1,231 @@
+import "reflect-metadata";
+import { UtilsOs__NS__isBrowser, UtilsOs__NS__isElectron, UtilsOs__NS__isNode, UtilsOs__NS__isWebSQL } from "tnp-core/lib-prod";
+import * as createContextFn from "./create-context";
+import * as getResponse from "./get-response-value";
+import * as injectFn from "./inject";
+export * from "./constants";
+export * from "./context-db-migrations";
+export * from "./create-context";
+export * from "./endpoint-context-storage";
+export * from "./endpoint-context";
+export * from "./entity-process";
+export * from "./get-response-value";
+export * from "./inject";
+export * from "./models";
+export * from "./symbols";
+export * from "./validators";
+export * from "./base-classes/base-abstract-entity";
+export * from "./base-classes/base-angular-service";
+export * from "./base-classes/base-class";
+export * from "./base-classes/base-context";
+export * from "./base-classes/base-controller";
+export * from "./base-classes/base-crud-controller";
+export * from "./base-classes/base-custom-repository";
+export * from "./base-classes/base-entity";
+export * from "./base-classes/base-file-upload.middleware";
+export * from "./base-classes/base-injector";
+export * from "./base-classes/base-middleware";
+export * from "./base-classes/base-migration";
+export * from "./base-classes/base-provider";
+export * from "./base-classes/base-repository";
+export * from "./base-classes/base-subscriber-for-entity";
+export * from "./config/controller-config";
+export * from "./config/controller-options";
+export * from "./config/method-config";
+export * from "./config/param-config";
+export * from "./decorators/decorator-abstract-opt";
+export * from "./dependency-injection/di-container";
+export * from "./helpers/class-helpers";
+export * from "./helpers/clone-obj";
+export * from "./helpers/taon-helpers";
+export * from "./orm/columns";
+export * from "./realtime/realtime-client";
+export * from "./realtime/realtime-core";
+export * from "./realtime/realtime-server";
+export * from "./realtime/realtime-subs-manager";
+export * from "./realtime/realtime.models";
+export * from "./decorators/classes/controller-decorator";
+export * from "./decorators/classes/entity-decorator";
+export * from "./decorators/classes/middleware-decorator";
+export * from "./decorators/classes/migration-decorator";
+export * from "./decorators/classes/provider-decorator";
+export * from "./decorators/classes/repository-decorator";
+export * from "./decorators/classes/subscriber-decorator";
+export * from "./decorators/http/http-methods-decorators";
+export * from "./decorators/http/http-params-decorators";
+export * from "./realtime/realtime-strategy/realtime-strategy-ipc";
+export * from "./realtime/realtime-strategy/realtime-strategy-mock";
+export * from "./realtime/realtime-strategy/realtime-strategy-socket-io";
+export * from "./realtime/realtime-strategy/realtime-strategy";
+const Taon__NS__removeLoader = (afterMS = 0) => {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      globalThis?.window?.document?.getElementById("taonpreloadertoremove")?.remove();
+      const body = globalThis?.window?.document?.body;
+      if (body && body.style) {
+        body.style.backgroundColor = "";
+      }
+      resolve();
+    }, afterMS);
+  });
+};
+const Taon__NS__error = (opt) => {
+  throw () => {
+    if (typeof opt === "string") {
+      opt = {
+        message: opt
+      };
+    }
+    return opt;
+  };
+};
+const Taon__NS__getResponseValue = getResponse.getResponseValue;
+const Taon__NS__isBrowser = UtilsOs__NS__isBrowser;
+const Taon__NS__isNode = UtilsOs__NS__isNode;
+const Taon__NS__isWebSQL = UtilsOs__NS__isWebSQL;
+const Taon__NS__isElectron = UtilsOs__NS__isElectron;
+const Taon__NS__createContext = createContextFn.createContext;
+const Taon__NS__createContextTemplate = createContextFn.createContextTemplate;
+const Taon__NS__inject = injectFn.inject;
+const Taon__NS__init = async (options) => {
+  const TaonBaseContext = (await import("./base-classes/base-context")).TaonBaseContext;
+  const context = Taon__NS__createContext(() => ({
+    appId: "default-app-not-used-anymore",
+    contextName: "default",
+    host: options.host,
+    contexts: { TaonBaseContext },
+    database: true,
+    entities: Array.from(options.entities),
+    controllers: Array.from(options.controllers)
+  }));
+  await context.initialize();
+  return context;
+};
+const TAON_FLATTEN_MAPPING = {
+  "taon/src": {
+    // =====================
+    // Taon.Http.*
+    // =====================
+    "Taon.Http.GET": "GET",
+    "Taon.Http.POST": "POST",
+    "Taon.Http.PUT": "PUT",
+    "Taon.Http.DELETE": "DELETE",
+    "Taon.Http.PATCH": "PATCH",
+    "Taon.Http.HEAD": "HEAD",
+    "Taon.Http.HTML": "HTML",
+    "Taon.Http.Response": "HttpResponse",
+    "Taon.Http.Param.Query": "Query",
+    "Taon.Http.Param.Path": "Path",
+    "Taon.Http.Param.Body": "Body",
+    "Taon.Http.Param.Cookie": "Cookie",
+    "Taon.Http.Param.Header": "Header",
+    // =====================
+    // Taon.Base.*
+    // =====================
+    "Taon.Base.Controller": "TaonBaseController",
+    "Taon.Base.CrudController": "TaonBaseCrudController",
+    "Taon.Base.Entity": "TaonBaseEntity",
+    "Taon.Base.AbstractEntity": "TaonBaseAbstractEntity",
+    "Taon.Base.AbstractEntityOmitKeys": "AbstractEntityOmitKeys",
+    "Taon.Base.Provider": "TaonBaseProvider",
+    "Taon.Base.Class": "TaonBaseClass",
+    "Taon.Base.Repository": "TaonBaseRepository",
+    "Taon.Base.CustomRepository": "TaonBaseCustomRepository",
+    "Taon.Base.SubscriberForEntity": "TaonBaseSubscriberForEntity",
+    "Taon.Base.Migration": "TaonBaseMigration",
+    "Taon.Base.Middleware": "TaonBaseMiddleware",
+    "Taon.Base.AngularService": "TaonBaseAngularService",
+    "Taon.Base.Context": "TaonBaseContext",
+    // =====================
+    // Taon.Controller.* (decorators)
+    // =====================
+    "Taon.Controller": "TaonController",
+    "Taon.Entity": "TaonEntity",
+    "Taon.Provider": "TaonProvider",
+    "Taon.Repository": "TaonRepository",
+    "Taon.Subscriber": "TaonSubscriber",
+    "Taon.Migration": "TaonMigration",
+    "Taon.Middleware": "TaonMiddleware",
+    // =====================
+    // Taon.Orm.*
+    // =====================
+    "Taon.Orm.Repository": "Repository",
+    "Taon.Orm.Connection": "Connection",
+    // ListenEvent
+    "Taon.Orm.ListenEvent.AfterInsert": "AfterInsert",
+    "Taon.Orm.ListenEvent.AfterLoad": "AfterLoad",
+    "Taon.Orm.ListenEvent.AfterRecover": "AfterRecover",
+    "Taon.Orm.ListenEvent.AfterRemove": "AfterRemove",
+    "Taon.Orm.ListenEvent.AfterSoftRemove": "AfterSoftRemove",
+    "Taon.Orm.ListenEvent.AfterUpdate": "AfterUpdate",
+    "Taon.Orm.ListenEvent.BeforeInsert": "BeforeInsert",
+    "Taon.Orm.ListenEvent.BeforeRecover": "BeforeRecover",
+    "Taon.Orm.ListenEvent.BeforeRemove": "BeforeRemove",
+    "Taon.Orm.ListenEvent.BeforeSoftRemove": "BeforeSoftRemove",
+    "Taon.Orm.ListenEvent.BeforeUpdate": "BeforeUpdate",
+    // Tree
+    "Taon.Orm.Tree.Children": "TreeChildren",
+    "Taon.Orm.Tree.Parent": "TreeParent",
+    // Column
+    "Taon.Orm.Column.Generated": "Generated",
+    "Taon.Orm.Column.Primary": "PrimaryColumn",
+    "Taon.Orm.Column.Index": "Index",
+    "Taon.Orm.Column.CreateDate": "CreateDateColumn",
+    "Taon.Orm.Column.UpdateDate": "UpdateDateColumn",
+    "Taon.Orm.Column.DeleteDate": "DeleteDateColumn",
+    "Taon.Orm.Column.Custom": "Column",
+    "Taon.Orm.Column.String": "StringColumn",
+    "Taon.Orm.Column.String100": "String100Column",
+    "Taon.Orm.Column.String45": "String45Column",
+    "Taon.Orm.Column.String500": "String500Column",
+    "Taon.Orm.Column.String200": "String200Column",
+    "Taon.Orm.Column.Number": "NumberColumn",
+    "Taon.Orm.Column.DecimalNumber": "DecimalNumberColumn",
+    "Taon.Orm.Column.SimpleJson": "SimpleJsonColumn",
+    "Taon.Orm.Column.Boolean": "BooleanColumn",
+    "Taon.Orm.Column.DateTIme": "DateTimeColumn",
+    "Taon.Orm.Column.Version": "VersionColumn",
+    "Taon.Orm.Column.Virtual": "VirtualColumn",
+    // Join
+    "Taon.Orm.Join.Table": "JoinTable",
+    "Taon.Orm.Join.Column": "JoinColumn",
+    // Relation
+    "Taon.Orm.Relation.OneToMany": "OneToMany",
+    "Taon.Orm.Relation.OneToOne": "OneToOne",
+    "Taon.Orm.Relation.ManyToMany": "ManyToMany",
+    "Taon.Orm.Relation.ManyToOne": "ManyToOne"
+  },
+  "taon-storage/src": {
+    // =====================
+    // Stor.* (new clean API)
+    // =====================
+    "Stor.Property.In.LocalStorage": "StorPropertyInLocalStorage",
+    "Stor.Property.In.IndexedDb": "StorPropertyInIndexedDb",
+    // short alias style (if you prefer this pattern in some codebases)
+    "Stor.In.LocalStorage": "StorPropertyInLocalStorage",
+    "Stor.In.IndexedDb": "StorPropertyInIndexedDb",
+    // =====================
+    // Stor.property.in.* (back-compat chain you mentioned)
+    // =====================
+    "Stor.property.in.localstorage": "StorPropertyInLocalStorage",
+    "Stor.property.in.indexedb": "StorPropertyInIndexedDb",
+    "Stor.property.in.indexedDb": "StorPropertyInIndexedDb",
+    // Optional: if your old code had Stor.proper... (typo)
+    "Stor.proper.in.localstorage": "StorPropertyInLocalStorage",
+    "Stor.proper.in.indexedb": "StorPropertyInIndexedDb"
+  }
+};
+export {
+  TAON_FLATTEN_MAPPING,
+  Taon__NS__createContext,
+  Taon__NS__createContextTemplate,
+  Taon__NS__error,
+  Taon__NS__getResponseValue,
+  Taon__NS__init,
+  Taon__NS__inject,
+  Taon__NS__isBrowser,
+  Taon__NS__isElectron,
+  Taon__NS__isNode,
+  Taon__NS__isWebSQL,
+  Taon__NS__removeLoader
+};

package/lib-prod/inject.js

@@ -0,0 +1,34 @@
+import { Symbols__NS__classMethodsNames, Symbols__NS__ctxInClassOrClassObj } from "./symbols";
+const inject = (entity) => {
+  return new Proxy(
+    {},
+    {
+      get: (_, propName) => {
+        if (propName === "hasOwnProperty") {
+          return () => false;
+        }
+        const ctor = entity();
+        const contextFromClass = ctor[Symbols__NS__ctxInClassOrClassObj];
+        const resultContext = contextFromClass;
+        if (resultContext) {
+          let instance = resultContext.inject(ctor, {
+            parentInstanceThatWillGetInjectedStuff: void 0
+          });
+          if (propName === "getOriginalPrototype") {
+            return () => Object.getPrototypeOf(instance);
+          }
+          if (propName === "getOriginalConstructor") {
+            return () => instance.constructor;
+          }
+          const methods = ctor[Symbols__NS__classMethodsNames] || [];
+          const isMethods = methods.includes(propName);
+          const methodOrProperty = isMethods ? instance[propName].bind(instance) : instance[propName];
+          return methodOrProperty;
+        }
+      }
+    }
+  );
+};
+export {
+  inject
+};

package/lib-prod/migrations/index.js

@@ -0,0 +1 @@
+export * from "./migrations_index._auto-generated_";