@trebco/treb 23.6.5 → 25.0.0-rc1

package/treb-base-types/src/union.ts

@@ -0,0 +1,152 @@
+/*
+ * 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 { ValueType, Complex, GetValueType, DimensionedQuantity } from './value-type';
+
+export type CellValue = undefined | string | number | boolean | Complex | DimensionedQuantity;
+
+/** 
+ * utility method 
+ * 
+ * @internal
+ */
+export const Is2DArray = <T>(obj: undefined|T|T[]|T[][]): obj is T[][] => {
+  return !!obj && Array.isArray(obj) && Array.isArray(obj[0]);
+}
+
+export interface NumberUnion {
+  type: ValueType.number;
+  value: number;
+}
+
+export interface StringUnion {
+  type: ValueType.string;
+  value: string;
+}
+
+export interface ErrorUnion {
+  type: ValueType.error;
+  value: string;
+}
+
+export interface FormulaUnion {
+  type: ValueType.formula;
+  value: string;
+}
+
+export interface BooleanUnion {
+  type: ValueType.boolean;
+  value: boolean;
+}
+
+/** we should have these for other types as well */
+export interface ComplexUnion {
+  type: ValueType.complex;
+  value: Complex;
+}
+
+export interface DimensionedQuantityUnion {
+  type: ValueType.dimensioned_quantity;
+  value: DimensionedQuantity;
+}
+
+export interface UndefinedUnion {
+  type: ValueType.undefined;
+  value?: undefined;
+}
+
+export interface ExtendedUnion {
+  type: ValueType.object;
+  value: any;
+  key?: string;
+}
+
+/** potentially recursive structure */
+export interface ArrayUnion {
+  type: ValueType.array;
+  value: UnionValue[][]; // 2d
+}
+
+/** switch to a discriminated union. implicit type guards! */
+export type UnionValue 
+    = NumberUnion 
+    | ArrayUnion 
+    | ComplexUnion
+    | DimensionedQuantityUnion 
+    | ExtendedUnion
+    | StringUnion 
+    | FormulaUnion
+    | UndefinedUnion
+    | BooleanUnion
+    | ErrorUnion
+    ;
+
+// common types
+
+/** 
+ * this is a factory instead of a constant value to prevent any accidental pollution
+ */
+// export const CreateUndefinedUnion = (): UnionValue => { 
+//  return { type: ValueType.undefined, value: undefined };
+//};
+
+/** 
+ * shortcut, although this is wasteful 
+ * 
+ * @internal
+ */
+export const Box = (value: unknown, type?: ValueType): UnionValue => { 
+  
+  // FIXME: type properly... instead of the GetValueType call
+
+  if (typeof type === 'undefined') {
+    type = GetValueType(value);
+  }
+
+  // assert? 
+
+  return {
+    value, 
+    type,
+  } as UnionValue;
+  
+};
+
+// export type UnionOrArray = UnionValue|UnionValue[][];
+
+/**
+ * box a complex value in a union, potentially switching to a real if
+ * there's no imaginary component.
+ * 
+ * @internal
+ */
+export const ComplexOrReal = (value: Complex): ComplexUnion|NumberUnion => {
+  if (value.imaginary) {
+    return {
+      type: ValueType.complex,
+      value,
+    };
+  }
+  return { type: ValueType.number, value: value.real };
+}
+
+
+

package/treb-base-types/src/value-type.ts

@@ -0,0 +1,164 @@
+/*
+ * 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
+ * 
+ */
+
+// split from cell for separate import, 
+// @see format-index.ts
+
+/**
+ * Complex number type
+ */
+export interface Complex {
+  real: number,
+  imaginary: number,
+}
+
+/** 
+ * typeguard
+ * 
+ * @internal
+ */
+export const IsComplex = (value: unknown): value is Complex => {
+  return (typeof value === 'object')
+          && (!!value)
+          && (typeof (value as Complex).real === 'number')
+          && (typeof (value as Complex).imaginary === 'number');
+};
+
+/**
+ * @internal
+ */
+export const ComplexToString = (value: Complex): string => {
+  if (value.real) {
+    if (value.imaginary) {
+      if (value.imaginary > 0) {
+        return `${value.real} + ${value.imaginary}i`;
+      }
+      else {
+        return `${value.real} - ${Math.abs(value.imaginary)}i`;
+      }
+    }
+    else {
+      return value.real.toString();
+    }
+  }
+  else if (value.imaginary) {
+    return value.imaginary + 'i';
+  }
+  else {
+    return '0';
+  }
+};
+
+export interface DimensionedQuantity {
+  value: number;
+  unit: string;
+}
+
+/**
+ * typeguard
+ *
+ * @internal
+ */
+export const IsDimensionedQuantity = (value: unknown): value is DimensionedQuantity => {
+  return (typeof value === 'object')
+          && (!!value)
+          && (typeof (value as DimensionedQuantity).value === 'number')
+          && (typeof (value as DimensionedQuantity).unit === 'string');
+};
+
+/**
+ * I _think_ using enums is faster. I'm not actually sure about that, though.
+ * it stands to reason that a single int compare is faster than a string
+ * compare, but you never know with javascript. undefined preferred over null.
+ * formula implies a string.
+ *
+ * undefined is 0 so we can test it as falsy.
+ *
+ * we're passing this type information out to calculators, so it needs
+ * to have known values. DO NOT MODIFY EXISTING INDEXES, or at least be
+ * aware of the implications. definitely do not change undefined => 0.
+ */
+export enum ValueType {
+  undefined = 0,
+
+  // formula is a string; we usually test the first character === '='
+  formula = 1,
+  string = 2,
+  number = 3,
+  boolean = 4,
+
+  // we don't actually use this type, it's here for matching only
+  object = 5,
+
+  // error is a STRING VALUE... object errors are layered on top? is that 
+  // correct? (...) it sort of makes sense... since we have separate typing
+  error = 6,
+
+  // complex is pretty stable by now
+  complex = 7,
+
+  // this is new though. this is not a cell value, it's 
+  // only for union types. perhaps we should move or rename 
+  // this array, and then cells could have a subset?
+  array = 8,
+
+  // adding DQ to union
+  dimensioned_quantity = 9,
+
+}
+
+/** @internal */
+export const GetValueType = (value: unknown): ValueType => {
+
+  switch (typeof value){
+    
+    case 'undefined':
+      return ValueType.undefined;
+
+    case 'number':
+      return ValueType.number;
+
+    case 'boolean':
+      return ValueType.boolean;
+
+    case 'object':
+      if (value === null) {
+        return ValueType.undefined;
+      }
+      else if (IsComplex(value)) {
+        return ValueType.complex;
+      }
+      else if (IsDimensionedQuantity(value)) {
+        return ValueType.dimensioned_quantity;
+      }
+      return ValueType.object;
+
+    case 'string':
+      if (value[0] === '=') {
+        return ValueType.formula;
+      }
+      return ValueType.string;
+
+    default: // function or symbol
+      return ValueType.error;
+
+  }
+}

package/treb-base-types/style/resizable.css

@@ -0,0 +1,59 @@
+/*
+ * 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
+ * 
+ */
+
+.treb-embed-mouse-mask {
+  position: fixed;
+  top: 0px;
+  left: 0px;
+  right: 0px;
+  bottom: 0px;
+  background: transparent;
+  z-index: 1000;
+  display: none;
+  cursor: nwse-resize;
+}
+
+.treb-embed-resize-rect {
+  box-sizing: border-box;
+  position: absolute;
+  /* border: 1px dotted #339966; */
+  border: 1px dotted #2e8dd6;
+  border-radius: 2px;
+  pointer-events: none;
+}
+
+.treb-embed-resize-handle {
+  box-sizing: border-box;
+  position: absolute;
+  height: 16px;
+  width: 16px;
+  min-height: 16px;
+  min-width: 16px;
+  /* border: 8px solid #339966; */
+  border: 8px solid #2e8dd6;
+
+  border-top-color: transparent;
+  border-left-color: transparent;
+  cursor: nwse-resize;
+  bottom: 1px;
+  right: 1px;
+  z-index: 999;
+}

package/treb-calculator/modern.tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../tsproject.json",
+  "references": [
+    { "path": "../treb-grid/modern.tsconfig.json" },
+    { "path": "../treb-utils/modern.tsconfig.json" }
+  ],
+  "include": [
+    "../treb-base-types/**/*.ts"
+  ]
+}
+

package/treb-calculator/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "treb-calculator",
+  "version": "16.0.0",
+  "main": "src/index.ts"
+}