@trebco/treb 23.6.5 → 25.0.0-rc2

package/treb-calculator/src/function-error.ts

@@ -0,0 +1,103 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import { UnionValue, ValueType } from 'treb-base-types';
+
+export enum ErrorType {
+  Argument =    'ARG',
+  Data =        'DATA',
+  Reference =   'REF',
+  Name =        'NAME',
+  Expression =  'EXPR',
+  Value =       'VALUE',
+  Unknown =     'UNK',
+  NotImpl =     'NOTIMPL',
+  Div0 =        'DIV/0',
+  NA =          'N/A',
+  Loop =        'LOOP', // circular reference
+}
+
+export interface FunctionError {
+  error: ErrorType;
+}
+
+// export const ArgumentError: FunctionError = { error: ErrorType.Argument };
+// export const ReferenceError: FunctionError = { error: ErrorType.Reference };
+//export const ExpressionError: FunctionError = { error: ErrorType.Expression };
+// export const NameError: FunctionError = { error: ErrorType.Name };
+// export const ValueError: FunctionError = { error: ErrorType.Value };
+// export const DataError: FunctionError = { error: ErrorType.Data };
+// export const DivideByZeroError: FunctionError = { error: ErrorType.Div0 };
+// export const UnknownError: FunctionError = { error: ErrorType.Unknown };
+export const NotImplError: FunctionError = { error: ErrorType.NotImpl };
+
+export const NAError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.NA };
+}
+
+export const ExpressionError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Expression };
+}
+
+export const DataError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Data };
+};
+
+export const DivideByZeroError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Div0 };
+};
+
+export const ArgumentError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Argument };
+};
+
+export const ValueError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Value };
+};
+
+export const ReferenceError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Reference };
+};
+
+export const NameError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Name };
+};
+
+export const UnknownError = (): UnionValue => {
+  return { type: ValueType.error, value: ErrorType.Unknown };
+};
+
+
+/** type guard function */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const IsError = (test: any): test is FunctionError => {
+  return test && typeof test.error && (
+    test.error === ErrorType.Argument ||
+    test.error === ErrorType.Reference ||
+    test.error === ErrorType.Name ||
+    test.error === ErrorType.Expression ||
+    test.error === ErrorType.Data ||
+    test.error === ErrorType.Unknown ||
+    test.error === ErrorType.NotImpl ||
+    test.error === ErrorType.Value ||
+    test.error === ErrorType.Div0
+  );
+};

package/treb-calculator/src/function-library.ts

@@ -0,0 +1,103 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import type { 
+  ExtendedFunctionDescriptor, CompositeFunctionDescriptor,
+  FunctionMap, ExtendedFunctionMap } from './descriptors';
+
+/**
+ * singleton (static instance) of function library; includes utility methods
+ */
+export class FunctionLibrary {
+
+  /** the actual functions */
+  protected functions: ExtendedFunctionMap = {};
+
+  /**
+   * register one or more functions. keys in the passed object are
+   * considered the canonical function names, and must be (icase) unique.
+   */
+  public Register(...maps: FunctionMap[]): void {
+
+    for (const map of maps) {
+
+      for (const name of Object.keys(map)) {
+
+        // some rules for names. the length thing is arbitrary, but come on.
+        // leading ascii-letter is also kind of arbitrary, but it can't be
+        // a number. the legal characters thing is probably broken: we should
+        // allow extended characters.
+
+        if (/[^a-zA-Z0-9._]/.test(name)) {
+          throw new Error('invalid function name (invalid character)');
+        }
+
+        if (name.length > 255) {
+          throw new Error('invalid function name (too long, > 255)');
+        }
+
+        if (/^[^a-zA-Z]/.test(name)) {
+          throw new Error('invalid function name (start with an ascii letter)');
+        }
+
+        const normalized = name.toLowerCase();
+        if (this.functions[normalized]) {
+          throw new Error(`function name (${normalized}) is already in use`);
+        }
+
+        const descriptor = map[name] as ExtendedFunctionDescriptor;
+        descriptor.canonical_name = name;
+
+        this.functions[normalized] = descriptor;
+      }
+
+    }
+
+  }
+
+  /** lookup function (actual map is protected) */
+  public Get(name: string) {
+    const normalized = name.toLowerCase();
+    return this.functions[normalized];
+  }
+
+  /** get a list, for AC services */
+  public List() {
+    const list: ExtendedFunctionMap = {};
+    for (const key of Object.keys(this.functions)) {
+      list[key] = this.functions[key];
+    }
+    return list;
+  }
+
+  /**
+   * create an alias. we clone the descriptor and use the alias as the
+   * canonical name, so should work better than just a pointer.
+   */
+  public Alias(name: string, reference: string) {
+    const ref = this.Get(reference);
+    if (!ref) {
+      throw new Error(`referenced function ${reference} does not exist`);
+    }
+    this.Register({[name]: {...ref} as CompositeFunctionDescriptor});
+  }
+
+}