@tachybase/plugin-field-formula 0.23.8

package/dist/index.js

@@ -0,0 +1,39 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  default: () => import_server.default
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./server"), module.exports);
+var import_server = __toESM(require("./server"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./server")
+});

package/dist/locale/en-US.json

@@ -0,0 +1,8 @@
+{
+  "Calculation engine": "Calculation engine",
+  "Compute a value based on the other fields": "Compute a value based on the other fields",
+  "Expression": "Expression",
+  "Expression syntax error": "Expression syntax error",
+  "Formula": "Formula",
+  "Syntax references": "Syntax references"
+}

package/dist/locale/ko_KR.json

@@ -0,0 +1,8 @@
+{
+  "Calculation engine": "계산 엔진",
+  "Compute a value based on the other fields": "다른 필드를 기반으로 값 계산",
+  "Expression": "표현식",
+  "Expression syntax error": "표현식 구문 오류",
+  "Formula": "수식",
+  "Syntax references": "구문 참조"
+}

package/dist/locale/zh-CN.json

@@ -0,0 +1,8 @@
+{
+  "Calculation engine": "计算引擎",
+  "Configure and store the results of calculations between multiple field values in the same record, supporting both Math.js and Excel formula functions.": "可以配置并存储同一条记录的多字段值之间的计算结果，支持 Math.js 和 Excel formula functions 两种引擎。",
+  "Expression": "表达式",
+  "Expression syntax error": "表达式语法错误",
+  "Formula": "公式",
+  "Syntax references": "语法参考"
+}

package/dist/server/field-formula.d.ts

@@ -0,0 +1,19 @@
+import { BaseFieldOptions, Field } from '@tachybase/database';
+export interface FormulaFieldOptions extends BaseFieldOptions {
+    type: 'formula';
+    engine: string;
+    expression: string;
+}
+export declare class FormulaField extends Field {
+    get dataType(): any;
+    calculate(scope: any): any;
+    initFieldData: ({ transaction }: {
+        transaction: any;
+    }) => Promise<void>;
+    calculateField: (instance: any) => Promise<void>;
+    updateFieldData: (instance: any, { transaction }: {
+        transaction: any;
+    }) => Promise<void>;
+    bind(): void;
+    unbind(): void;
+}

package/dist/server/field-formula.js

@@ -0,0 +1,118 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var field_formula_exports = {};
+__export(field_formula_exports, {
+  FormulaField: () => FormulaField
+});
+module.exports = __toCommonJS(field_formula_exports);
+var import_database = require("@tachybase/database");
+var import_evaluators = require("@tachybase/evaluators");
+var import_utils = require("../utils");
+const DataTypeMap = {
+  boolean: import_database.DataTypes.BOOLEAN,
+  integer: import_database.DataTypes.INTEGER,
+  bigInt: import_database.DataTypes.BIGINT,
+  double: import_database.DataTypes.DOUBLE,
+  decimal: import_database.DataTypes.DECIMAL,
+  string: import_database.DataTypes.STRING,
+  date: import_database.DataTypes.DATE(3)
+};
+class FormulaField extends import_database.Field {
+  get dataType() {
+    const { dataType } = this.options;
+    return DataTypeMap[dataType] ?? import_database.DataTypes.DOUBLE;
+  }
+  calculate(scope) {
+    const { expression, engine = "math.js", dataType = "double" } = this.options;
+    const evaluate = import_evaluators.evaluators.get(engine);
+    try {
+      const result = evaluate(expression, scope);
+      return (0, import_utils.toDbType)(result, dataType);
+    } catch (e) {
+      console.error(e);
+    }
+    return null;
+  }
+  initFieldData = async ({ transaction }) => {
+    const { name } = this.options;
+    const records = await this.collection.repository.find({
+      order: [this.collection.model.primaryKeyAttribute],
+      transaction
+    });
+    for (const record of records) {
+      const scope = record.toJSON();
+      const result = this.calculate(scope);
+      if (result != null) {
+        await record.update(
+          {
+            [name]: result
+          },
+          {
+            transaction,
+            silent: true,
+            hooks: false
+          }
+        );
+      }
+    }
+  };
+  calculateField = async (instance) => {
+    const { name } = this.options;
+    const result = this.calculate(instance.toJSON());
+    instance.set(name, result);
+  };
+  updateFieldData = async (instance, { transaction }) => {
+    if (this.collection.name !== instance.collectionName || instance.name !== this.options.name) {
+      return;
+    }
+    this.options = Object.assign(this.options, instance.options);
+    const { name } = this.options;
+    const records = await this.collection.repository.find({
+      order: [this.collection.model.primaryKeyAttribute],
+      transaction
+    });
+    for (const record of records) {
+      const scope = record.toJSON();
+      const result = this.calculate(scope);
+      await record.update(
+        {
+          [name]: result
+        },
+        {
+          transaction,
+          silent: true,
+          hooks: false
+        }
+      );
+    }
+  };
+  bind() {
+    super.bind();
+    this.database.on("fields.afterUpdate", this.updateFieldData);
+    this.on("beforeSave", this.calculateField);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeSave", this.calculateField);
+    this.database.off("fields.afterUpdate", this.updateFieldData);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormulaField
+});

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin';

package/dist/server/index.js

@@ -0,0 +1,33 @@
+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 server_exports = {};
+__export(server_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/migrations/20230213161904-alter-field.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20230213161904-alter-field.js

@@ -0,0 +1,62 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var alter_field_exports = {};
+__export(alter_field_exports, {
+  default: () => alter_field_default
+});
+module.exports = __toCommonJS(alter_field_exports);
+var import_server = require("@tachybase/server");
+class alter_field_default extends import_server.Migration {
+  appVersion = "<=0.9.0-alpha.3";
+  async up() {
+    const result = await this.app.version.satisfies("<=0.9.0-alpha.3");
+    if (!result) {
+      return;
+    }
+    const { db } = this.context;
+    await db.sequelize.transaction(async (transaction) => {
+      const Field = db.getRepository("fields");
+      const fields = await Field.find({ transaction });
+      for (const field of fields) {
+        if (["mathFormula", "excelFormula"].includes(field.get("type"))) {
+          const { options } = field;
+          field.set({
+            type: "formula",
+            interface: "formula",
+            options: {
+              ...options,
+              engine: field.get("type") === "mathFormula" ? "math.js" : "formula.js",
+              dataType: options.dataType === "number" ? "double" : "string"
+            }
+          });
+          await field.save({ transaction });
+          const schema = await field.getUiSchema({ transaction });
+          schema.set("x-component", "Formula.Result");
+          await schema.save({ transaction });
+        }
+      }
+      const repository = db.getRepository("applicationPlugins");
+      await repository.destroy({
+        filter: {
+          name: ["math-formula-field", "excel-formula-field"]
+        },
+        transaction
+      });
+    });
+  }
+}

package/dist/server/plugin.d.ts

@@ -0,0 +1,11 @@
+import { InstallOptions, Plugin } from '@tachybase/server';
+export declare class FormulaFieldPlugin extends Plugin {
+    afterAdd(): void;
+    beforeLoad(): void;
+    load(): Promise<void>;
+    install(options?: InstallOptions): Promise<void>;
+    afterEnable(): Promise<void>;
+    afterDisable(): Promise<void>;
+    remove(): Promise<void>;
+}
+export default FormulaFieldPlugin;

package/dist/server/plugin.js

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  FormulaFieldPlugin: () => FormulaFieldPlugin,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_path = require("path");
+var import_server = require("@tachybase/server");
+var import_field_formula = require("./field-formula");
+class FormulaFieldPlugin extends import_server.Plugin {
+  afterAdd() {
+  }
+  beforeLoad() {
+    this.db.registerFieldTypes({
+      formula: import_field_formula.FormulaField
+    });
+    this.db.addMigrations({
+      namespace: this.name,
+      directory: (0, import_path.resolve)(__dirname, "./migrations"),
+      context: {
+        plugin: this
+      }
+    });
+  }
+  async load() {
+  }
+  async install(options) {
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+  }
+  async remove() {
+  }
+}
+var plugin_default = FormulaFieldPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormulaFieldPlugin
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,45 @@
+export declare const DataTypeTransformers: {
+    boolean: BooleanConstructor;
+    integer: {
+        boolean(value: boolean): number;
+        number(value: number): number;
+        bigint(value: bigint): number;
+        string(value: string): number;
+        date(value: Date): number;
+    };
+    bigInt: {
+        boolean(value: boolean): number;
+        number(value: number): number;
+        bigint(value: bigint): number;
+        string(value: string): number;
+        date(value: Date): number;
+    };
+    double: {
+        boolean(value: boolean): number;
+        number(value: number): number;
+        bigint(value: bigint): number;
+        string(value: string): number;
+        date(value: Date): number;
+    };
+    decimal: {
+        boolean(value: boolean): number;
+        number(value: number): number;
+        bigint(value: bigint): bigint;
+        date(value: Date): number;
+    };
+    string: {
+        boolean(value: boolean): string;
+        number(value: number): string;
+        bigint(value: bigint): string;
+        string(value: string): string;
+        date(value: Date): string;
+    };
+    date: {
+        boolean(value: boolean): any;
+        number(value: number): Date;
+        bigint(value: bigint): Date;
+        string(value: string): Date;
+        date(value: Date): Date;
+    };
+};
+export declare function toDbType(value: any, type: string): any;

package/dist/utils/index.js

@@ -0,0 +1,188 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  DataTypeTransformers: () => DataTypeTransformers,
+  toDbType: () => toDbType
+});
+module.exports = __toCommonJS(utils_exports);
+const DataTypeTransformers = {
+  boolean: Boolean,
+  integer: {
+    boolean(value) {
+      return Number(value);
+    },
+    number(value) {
+      return value >= 0 ? Math.floor(value) : Math.ceil(value);
+    },
+    bigint(value) {
+      return Number(value);
+    },
+    string(value) {
+      const result = Number.parseInt(value, 10);
+      if (Number.isNaN(result) || !Number.isFinite(result)) {
+        return null;
+      }
+      return result;
+    },
+    date(value) {
+      const result = value.valueOf();
+      if (Number.isNaN(result)) {
+        return null;
+      }
+      return result;
+    }
+  },
+  bigInt: {
+    boolean(value) {
+      return Number(value);
+    },
+    number(value) {
+      return Math.floor(value >= 0 ? Math.floor(value) : Math.ceil(value));
+    },
+    bigint(value) {
+      return Number(value);
+    },
+    string(value) {
+      const result = Number.parseInt(value, 10);
+      if (Number.isNaN(result) || !Number.isFinite(result)) {
+        return null;
+      }
+      return result;
+    },
+    date(value) {
+      const result = value.valueOf();
+      if (Number.isNaN(result)) {
+        return null;
+      }
+      return result;
+    }
+  },
+  double: {
+    boolean(value) {
+      return Number(value);
+    },
+    number(value) {
+      return value;
+    },
+    bigint(value) {
+      return Number(value);
+    },
+    string(value) {
+      const result = Number.parseFloat(value);
+      if (Number.isNaN(result) || !Number.isFinite(result)) {
+        return null;
+      }
+      return result;
+    },
+    date(value) {
+      const result = value.valueOf();
+      if (Number.isNaN(result)) {
+        return null;
+      }
+      return result;
+    }
+  },
+  decimal: {
+    boolean(value) {
+      return Number(value);
+    },
+    number(value) {
+      return value;
+    },
+    bigint(value) {
+      return value;
+    },
+    date(value) {
+      const result = value.valueOf();
+      if (Number.isNaN(result)) {
+        return null;
+      }
+      return result;
+    }
+  },
+  string: {
+    boolean(value) {
+      return value.toString();
+    },
+    number(value) {
+      return value.toString();
+    },
+    bigint(value) {
+      return value.toString();
+    },
+    string(value) {
+      return value;
+    },
+    date(value) {
+      return value.toISOString();
+    }
+  },
+  date: {
+    boolean(value) {
+      return null;
+    },
+    number(value) {
+      const result = new Date(value);
+      if (Number.isNaN(result.valueOf())) {
+        return null;
+      }
+      return result;
+    },
+    bigint(value) {
+      const result = new Date(Number(value));
+      if (Number.isNaN(result.valueOf())) {
+        return null;
+      }
+      return result;
+    },
+    string(value) {
+      const ts = Date.parse(value);
+      if (Number.isNaN(ts)) {
+        return null;
+      }
+      return new Date(ts);
+    },
+    date(value) {
+      return new Date(value);
+    }
+  }
+};
+function toDbType(value, type) {
+  if (value == null) {
+    return null;
+  }
+  let jsType = typeof value;
+  if (jsType == "object" && value instanceof Date) {
+    jsType = "date";
+  }
+  const transformers = DataTypeTransformers[type];
+  if (!transformers) {
+    return null;
+  }
+  if (typeof transformers === "function") {
+    return transformers(value);
+  }
+  const transformer = transformers[jsType];
+  return transformer ? transformer(value) : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataTypeTransformers,
+  toDbType
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@tachybase/plugin-field-formula",
+  "displayName": "Field: Formula",
+  "version": "0.23.8",
+  "description": "Configure and store the results of calculations between multiple field values in the same record, supporting both Math.js and Excel formula functions.",
+  "keywords": [
+    "Collection fields"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/server/index.js",
+  "devDependencies": {
+    "react": "^18.3.1",
+    "react-i18next": "^15.2.0",
+    "@tachybase/schema": "0.23.8",
+    "@tachybase/components": "0.23.8"
+  },
+  "peerDependencies": {
+    "@tachybase/client": "0.23.8",
+    "@tachybase/database": "0.23.8",
+    "@tachybase/evaluators": "0.23.8",
+    "@tachybase/server": "0.23.8",
+    "@tachybase/test": "0.23.8",
+    "@tachybase/utils": "0.23.8"
+  },
+  "description.zh-CN": "可以配置并存储同一条记录的多字段值之间的计算结果，支持 Math.js 和 Excel formula functions 两种引擎",
+  "displayName.zh-CN": "数据表字段：公式",
+  "scripts": {
+    "build": "tachybase-build --no-dts @tachybase/plugin-field-formula"
+  }
+}

package/server.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/server';
+export { default } from './dist/server';

package/server.js

@@ -0,0 +1 @@
+module.exports = require('./dist/server/index.js');