@trebco/treb 23.6.2 → 25.0.0-rc1

package/treb-utils/src/scale.ts

@@ -0,0 +1,137 @@
+/*
+ * 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
+ * 
+ */
+
+/** calculated human-friendly scale for rendering axes */
+export interface RangeScale {
+  scale: number;
+  step: number;
+  count: number;
+  min: number;
+  max: number;
+}
+
+/**
+ * making this a little more generic so we can use it outside of charts.
+ * specifically, for the sheet "histogram table" function. for that, we
+ * do need to ensure that the count is not greater than our request.
+ * 
+ * we have a new parameter for that, default behavior should not change.
+ */
+export const Scale = (min: number, max: number, count = 6.5, limit_count = false, discrete = false): RangeScale => {
+
+  if (max === min) { 
+
+    // we should either have optional behavior here or have this as
+    // some sort of wrapper method -- it just seems arbitrary
+
+    max++;
+    if (min) {
+      min--;
+    }
+  }
+  else {
+    
+    // let's fix this specific problem, where you get accumulated fp errors. round to 5 places...
+
+    // const tmp_range = max - min;
+    const rounded = Math.round(max * 100000) / 100000;
+
+    if (Math.abs(rounded - max) / (max - min) < 1e-5) {
+      max = rounded;
+    }
+    
+  }
+
+  const range = max - min;
+
+  const log10 = Math.log(range) / Math.log(10); // just avoid the problem (problem being IE11 lack of Math.log10)
+
+  let scale = Math.floor(Math.abs(log10)) * (log10 < 0 ? -1 : 1) - 1;
+
+  // so if you claim you have discrete data, we want the minimum 
+  // step to be 1. we also have slightly different acceptable steps.
+
+  if (discrete) {
+    scale = Math.max(0, scale);
+  }
+  
+  const steps = discrete ? 
+      [1, 2, 5, 10, 15, 20, 25, 50, 100] : 
+      [.1, .25, .5, 1, 2.5, 5, 10, 25, 50, 100];
+
+  let step = -1;
+  let delta = 0;
+
+  for (const x of steps) {
+    const test_step = x * Math.pow(10, scale);
+    const test_min = Math.floor(min / test_step) * test_step;
+    const test_max = Math.ceil(max / test_step) * test_step;
+    const test_count = (test_max - test_min) / test_step;
+    const test_delta = Math.abs(test_count - count);
+
+    if (step < 0 || test_delta < delta) {
+      if (!limit_count || (test_count <= count)) {
+        delta = test_delta;
+        step = test_step;
+      }
+    }
+
+    /*
+    else if (!limit_count && (test_delta < delta)) {
+      delta = test_delta;
+      step = test_step;
+    }
+    else if (limit_count && test_delta < delta && test_count <= count) {
+      delta = test_delta;
+      step = test_step;
+    }
+    */
+
+    /*
+
+    if (step < 0 || test_delta < delta){
+      delta = test_delta;
+      step = test_step;
+    }
+    else if (step >= 0 && test_delta > delta) {
+      if (limit_count) {
+        min = Math.floor(min / step) * step;
+        max = Math.ceil(max / step) * step;
+        const check = Math.round((max - min) / step);
+        if (check > count) { 
+          delta = test_delta;
+          step = test_step;
+          continue; 
+        }
+      }
+      break;
+    }
+    */
+
+  }
+
+  min = Math.floor(min / step) * step;
+  max = Math.ceil(max / step) * step;
+  count = Math.round((max - min) / step); // accounts for fp errors
+
+  return { scale, step, count, min, max };
+
+}

package/treb-utils/src/serialize_html.ts

@@ -0,0 +1,124 @@
+/*
+ * 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
+ * 
+ */
+
+interface StringMap {
+  [index: string]: string;
+}
+
+/**
+ * defaults are global, since we assume they never change. created on demand.
+ */
+let default_properties: StringMap|undefined;
+
+/**
+ * get applied style as text (for attribute)
+ */
+const GetAppliedStyle = (node: Element, computed: CSSStyleDeclaration, defaults: StringMap) => {
+
+  const applied: StringMap = {};
+
+  Array.prototype.forEach.call(computed, (key) => {
+    if (computed[key] !== defaults[key]) {
+      applied[key] = computed[key];
+    }
+  });
+
+  return (Object.keys(applied).map((key) => `${key}: ${applied[key]}`).join('; ') +
+    '; ' + (node.getAttribute('style') || '')).trim().replace(/"/g, '\'');
+
+};
+
+/**
+ * create a clone of the node with static styles applied
+ */
+const RenderNode = (node: Element, defaults: StringMap) => {
+
+  const clone = node.cloneNode(false);
+  const computed = getComputedStyle(node);
+  const style = GetAppliedStyle(node, computed, defaults);
+
+  (clone as HTMLElement).removeAttribute('class');
+  (clone as HTMLElement).setAttribute('style', style);
+
+  Array.prototype.forEach.call(node.childNodes, (child: Node) => {
+
+    switch (child.nodeType) {
+
+      case Node.ELEMENT_NODE:
+        // here we use the parent as the default style, assuming the child will inherit
+        clone.appendChild(RenderNode(child as Element, computed as any));
+        break;
+
+      case Node.TEXT_NODE:
+        if (node.textContent) {
+          clone.appendChild(document.createTextNode(node.textContent));
+        }
+        break;
+
+      case Node.COMMENT_NODE:
+        // silently drop comments
+        break;
+
+      default:
+        console.warn('unhandled node type in serialize', child);
+    }
+});
+
+  return clone;
+};
+
+/**
+ * serialize a node by creating a clone with static styling that can be
+ * used stand-alone (intended for svg, but could apply generically).
+ */
+export const SerializeHTML = (node: Element) => {
+
+  if (!default_properties) {
+
+    const defaults: StringMap = {};
+
+    const iframe = document.createElement('iframe');
+    iframe.style.width = '10px';
+    iframe.style.height = '10px';
+    iframe.style.position = 'absolute';
+    iframe.style.left = '-100px';
+
+    document.body.appendChild(iframe);
+
+    const frame_document = iframe.contentDocument;
+    if (frame_document) {
+      const div = frame_document.createElement('div');
+      frame_document.body.appendChild(div);
+      const computed = getComputedStyle(div);
+      Array.prototype.forEach.call(computed, (key) => defaults[key] = computed[key]);
+    }
+
+    document.body.removeChild(iframe);
+    default_properties = defaults;
+
+  }
+
+  return RenderNode(node, default_properties);
+
+};
+
+// (self as any).SerializeHTML = SerializeHTML;
+

package/treb-utils/src/template.ts

@@ -0,0 +1,70 @@
+/*
+ * 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
+ * 
+ */
+
+export interface NodeModel {[index: string]: HTMLElement}
+
+const ParseTail = (node: HTMLElement, scope: string, model: NodeModel): void => {
+  [].forEach.call(node.children, (child: HTMLElement) => {
+    if (child.id) {
+      model[child.id] = child;
+      child.id = `${scope}-${child.id}`;
+    }
+    if (child.children && child.children.length) {
+      ParseTail(child, scope, model);
+    }
+});
+}
+
+const ParseTemplate = (template: string, container?: HTMLElement|string) => {
+
+  const scope = Math.random().toString(36).substring(2, 15);
+  const temp = document.createElement('div');
+  temp.innerHTML = template;
+
+  const model: NodeModel = {};
+  ParseTail(temp, scope, model);
+
+  if (typeof container === 'string') {
+    container = document.querySelector(container) as HTMLElement;
+  }
+  if (container) {
+    const nodes = [].map.call(temp.childNodes, child => child);
+    for (const child of nodes) { container.appendChild(child as Node); }
+  }
+ 
+  return model;
+
+}
+
+export const composite = (strings: TemplateStringsArray, ...args: any[]): string => {
+  const output: string[] = [];
+  for (let i = 0; i < strings.length; i++) {
+    output.push(strings[i]);
+    if (args[i]) { output.push(args[i].toString()); }
+  }
+  return output.join('');
+}
+
+export const tmpl = (strings: TemplateStringsArray, ...args: any[]): NodeModel => {
+  return ParseTemplate(composite(strings, ...args));
+}
+
+export const css = composite;

package/treb-utils/src/validate_uri.ts

@@ -0,0 +1,61 @@
+
+/**
+ * TODO: possibly add an allow-list for remotes
+ */
+export interface ValidURIOptions {
+  
+  /** allow data: uri (default true) */
+  data: boolean; 
+
+  /** allow same-origin (default true) */
+  same_origin: boolean;
+
+  /** allow remote (default false) */
+  remote: boolean;
+
+}
+
+const default_uri_options: ValidURIOptions = {
+  data: true,
+  same_origin: true,
+  remote: false,
+};
+
+/**
+ * check if this resource is a valid URI. by default we only 
+ * allow data: and same-origin URIs, but you can override that
+ * with a flag.
+ * 
+ * this assumes we have a document (and location) so it should
+ * only be called from browser context.
+ */
+export const ValidateURI = (resource: string, options: Partial<ValidURIOptions> = {}): string|undefined => {
+
+  const composite: ValidURIOptions = {
+    ...default_uri_options,
+    ...options,
+  };
+
+  // console.info({composite});
+
+  try {
+    const url = new URL(resource, document.location.href);
+    
+    if (url.protocol === 'data:') {
+      return composite.data ? url.href : undefined;
+    }
+    
+    if (url.origin === document.location.origin) {
+      return composite.same_origin ? url.href : undefined;
+    }
+
+    return composite.remote ? url.hash : undefined;
+
+  }
+  catch (err) {
+    console.error(err);
+  }
+
+  return undefined;
+
+};

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+  },
+  "references": [
+    { "path": "./treb-embed/modern.tsconfig.json" },
+    { "path": "./treb-export/modern.tsconfig.json" }
+  ],
+  "files": []
+}

package/tsproject.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationDir": "declaration",
+    "target": "esnext",
+    "module": "es2020",
+    "strict": true,
+    "composite": true,
+    "baseUrl": "./",
+    "outDir": "./dist",
+    "experimentalDecorators": true,
+    "downlevelIteration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "rootDir": ".",
+    "importHelpers": true,
+    "noEmitHelpers": true,
+    "importsNotUsedAsValues": "error",
+    "lib": [
+      "dom", "es2015"
+    ],
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true
+  },
+  "exclude": [
+    "node_modules",
+    "external-declaration-files"
+  ]
+}

package/util/license-plugin-esbuild.js

@@ -0,0 +1,86 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+/**
+ * this is a replacement (more or less) for `license-checker-webpack-plugin`
+ * for use with esbuild. we can get the metafile from an esbuild run, and 
+ * use that to find deps and list licenses. 
+ * 
+ * TODO: rewrite this in ts
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * find the license, if any, for the given module. returns a string for
+ * inclusion into the license file, structured as
+ * 
+ * name (repo name if no name in package)
+ * repo url (if available)
+ * license text...
+ * 
+ */
+const FindLicense = async (dir) => {
+
+  try {
+    const text = await fs.promises.readFile(path.join(dir, 'package.json'), { encoding: 'utf8'});
+    const json = JSON.parse(text || '{}');
+    const files = (await fs.promises.readdir(dir)).filter(test => /license/i.test(test));
+
+    let name = json.name || '';
+
+    if (!name) {
+      const split = dir.split(path.sep);
+      name = split[1];
+    }
+
+    let strings = [name];
+
+    if (typeof json.repository === 'object' && json.repository.url) {
+      strings.push(json.repository.url);
+    }
+    else if (typeof json.repository === 'string') {
+      strings.push(json.repository);
+    }
+
+    if (files.length > 0) {
+      const license_text = await fs.promises.readFile(path.join(dir, files[0]), { encoding: 'utf8' });
+      strings.push('\n');
+      strings.push(license_text);
+      return strings.join('\n');
+    }
+
+  }
+  catch (err) {
+    console.error(err);
+  }
+
+  return undefined;
+
+};
+
+const GenerateLicenseFile = async (metafile) => {
+
+  let processed = new Map();
+  const licenses = [];
+
+  for (const key of Object.keys(metafile.inputs || {})) {
+    if (/^node_modules/.test(key)) {
+      const parts = key.split(path.sep);
+      if (!processed.has(parts[1])) {
+        const license = await FindLicense(path.join(parts[0], parts[1]));
+        if (license) {
+          licenses.push(license);
+        }
+        processed.set(parts[1], true);
+      }
+    }
+  }
+
+  return licenses.join('\n---\n\n');
+
+};
+
+module.exports = { GenerateLicenseFile };
+
+

package/util/list-css-vars.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+
+#
+# print a list of all --treb css vars used in any treb* directory. 
+# uses bash wizardry.
+#
+# of course you should be noting these when you create them. but
+# this is a useful check that we haven't missed anything.
+#
+# note that we're specifically looking for vars being /used/, not 
+# /defined/. which is probably better in case we have vars we're 
+# defining but never using.
+#
+
+regexp="(--treb[[:alnum:]_\-]+)"
+
+# search and filter
+unique=($(
+  for i in `grep -ir "var(\\s*--treb" treb*`; do
+    if [[ $i =~ $regexp ]]; then
+      echo "${BASH_REMATCH[1]}";
+    fi
+  done | sort -u))
+
+## dump uniques
+#for i in ${unique[@]}; do
+#  echo $i
+#done;
+
+# update: dump as JSON. this is beyond my bashing skills, 
+# have to have an empty string
+
+# update2: OK I can do it, but it's ugly
+
+FIRST=1
+printf "[\n"
+for i in ${unique[@]}; do
+  if [[ $FIRST -ne 1 ]]; then
+    printf ",\n";
+  fi;
+  printf '\t"%s"' $i
+  FIRST=0
+done;
+printf "\n]\n"
+
+

package/README-esm.md

@@ -1,37 +0,0 @@
-
-# ES module
-
-This directory is provided to make it easier to consume TREB as an 
-es module, particularly if you are using a front-end framework.
-
-
-## Why is the ES module larger than the JS module?
-
-Traditionally, we split import/export functions (functions that operate
-on XLSX files) into a separate worker module which is loaded on demand.
-If you are using the JS module as a web resource, we locate the worker 
-script using the path to the base script.
-
-That doesn't necessarily work if you are using a bundler, which
-is commmon with front-end frameworks. It's possible to manually place the 
-worker script in a public asset directory, and set the path, but that makes
-it much more difficult to import the library.
-
-So as of version 21.2, we're including the import/export worker in the 
-MJS file as a blob, and loading the worker from that blob as necessary.
-
-
-## The ES module does not embed CSS
-
-The JS module embeds CSS -- styles are attached to the document when
-the JS module is loaded. 
-
-The ES module does not embed CSS, to better support strict CSP settings. So 
-if you use the ES module, you must separately include the stylesheet, 
-either in your HTML or using your front-end framework.
-
-
-# How to use the ES module
-
-See README.md in this directory.
-