@trebco/treb 23.6.2 → 25.0.0-rc1

package/treb-format/src/format_cache.ts

@@ -0,0 +1,199 @@
+/*
+ * 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 { NumberFormat } from './format';
+
+/**
+ * since users almost always make caches, we might as well
+ * support a universal cache. also universal base (named) types.
+ *
+ * note that for this reason, you shouldn't mutate number formats.
+ * mutate copies instead.
+ */
+export class NumberFormatCache {
+
+  /** cache instance */
+  private static cache: {[index: string]: NumberFormat} = {};
+
+  /** special case for the "general" formatter for complex numbers only */
+  private static complex_general: NumberFormat;
+
+  /** 
+   * this map is for case-insensitive mapping symbolic names to formats. we
+   * want symbolic names with casing, primarily for interop, but we also want
+   * to support icase matching.
+   * 
+   * FIXME: is there a better way to do this, with a pattern or something in
+   * the cache?
+   */
+  private static symbolc_name_map: {[index: string]: string} = {};
+
+  /** base types, with default names */
+  private static base_formats: {[index: string]: string} = {
+
+    Accounting: '_(#,##0.00_);(#,##0.00);-???',
+    Number: '0.00',
+    Integer: '0',
+    Percent: '0.00%',
+    General: '0.######', // for complex we will reduce the number of optional digits
+    Fraction: '# ?/?',
+    Dollar: '$* _(#,##0.00_);$* (#,##0.00);$* -???',
+    Exponential: '0.000e',
+
+    'Short Date': 'mm/dd/yy',
+    'Long Date': 'dddd, mmm d yyyy',
+    Timestamp: 'mm-dd-yy hh:mm:ss',
+
+  };
+
+  /** alias types */
+  private static aliases: {[index: string]: string} = {
+
+    Scientific: 'Exponential',
+    Percentage: 'Percent',
+    Currency: 'Dollar',
+
+    /*
+    // we switched to Uppercase symbolic names to better
+    // match imported files, but we have legacy stuff using
+    // lowercase, so add aliases.
+
+    accounting: 'Accounting',
+    number: 'Number',
+    integer: 'Integer',
+    percent: 'Percent',
+    general: 'General',
+    dollar: 'Dollar',
+    exponential: 'Exponential',
+
+    'short date': 'Short Date',
+    'long date': 'Long Date',
+    timestamp: 'Timestamp',
+    */
+
+  };
+
+  /**
+   * we now have (some) overlay styles for complex. if the flag is set
+   * we will check the complex cache first, and 
+   * @param format 
+   * @param complex 
+   * @returns 
+   */
+  public static Get(format: string, complex = false): NumberFormat {
+
+    if (complex && format === 'General') {
+      return this.complex_general;
+    }
+
+    // FIXME: we should use icase for symbolc formats, although not
+    // for format strings. there should (hopefully) be no case where
+    // these overlap.
+
+    const canonical_name = this.symbolc_name_map[format.toLowerCase()];
+
+    let formatter = this.cache[canonical_name || format];
+    
+    if (!formatter) {
+      formatter = new NumberFormat(format);
+      this.cache[format] = formatter;
+    }
+    return formatter;
+  }
+
+  /** 
+   * does anyone use this? (...)
+   */
+  public static Equals(a: string, b: string): boolean {
+    if (a === b) return true;
+    const fa = this.Get(a);
+    const fb = this.Get(b);
+    return fa.pattern === fb.pattern;
+  }
+
+  /**
+   * this method is used to translate symbolic formats,
+   * without actually creating a formatter. it's a shortcut
+   * we need for exporting to xlsx.
+   *
+   * if the passed format matches a symbolic format, we return
+   * the string representation. if it doesn't match any symbolic format,
+   * the string is returned as-is.
+   */
+  public static Translate(format: string): string {
+
+    const mapped = this.symbolc_name_map[format.toLowerCase()];
+    return mapped ? this.cache[mapped].toString() : format;
+
+    // const formatter = this.cache[format];
+    // if (formatter) { return formatter.toString(); }
+    // return format;
+  }
+
+  /**
+   * check if the format (as a number format) matches a local 
+   * symbolic name and if so, return that.
+   */
+  public static SymbolicName(format: string): string|null {
+    for (const key of Object.keys(this.base_formats)){
+      if (format === this.base_formats[key]) return key;
+    }
+    return null;
+  }
+
+  public static InitCache(): void {
+
+    for (const key of Object.keys(this.base_formats)) {
+      this.cache[key] = new NumberFormat(this.base_formats[key]);
+      this.symbolc_name_map[key.toLowerCase()] = key;
+    }
+
+    // we're doing this to hide it, but we might as well allow it
+    // since js interfaces will find it regardless
+
+    this.cache['General'].magic_decimal = true;
+
+    // special general type for complex has fewer digits by default
+
+    this.complex_general = new NumberFormat('0.###');
+    this.complex_general.magic_decimal = true;
+
+    for (const key of Object.keys(this.aliases)) {
+      this.cache[key] = this.cache[this.aliases[key]];
+      this.symbolc_name_map[key.toLowerCase()] = key;
+    }
+
+  }
+
+}
+
+// is there a pattern for this? or a preferred way? I'm actually
+// concerned that an optimizer might remove the method.
+
+NumberFormatCache.InitCache();
+
+/*
+// DEV: expose objects to console
+if (process.env.NODE_ENV !== 'production') {
+  (self as any).NumberFormatCache = NumberFormatCache;
+  (self as any).NumberFormat = NumberFormat;
+}
+*/