@jarenjs/calc 0.56.0 → 0.67.0

package/README.md

@@ -47,6 +47,12 @@ depreciation, bond, indicators, returns) and `@jarenjs/core/convert`
 primitive). The calculator's financial mode calls `core/finance`; its
 converter calls `core/convert`. Core is pure and never fetches.
 
+Changing the converter dimension updates its unit selections in the same
+transition. Existing choices survive when the new dimension offers them;
+otherwise it selects the first two available units (the same unit for both
+sides when only one exists). Currency choices come from the current rate
+table. A dimension with no available units leaves the conversion unchanged.
+
 ## Live currency (the maturity example)
 
 The converter's currency dimension takes live crypto+fiat rates from free
@@ -55,6 +61,26 @@ public tickers (CoinGecko default, Binance alternative) through an
 conversion** is `@jarenjs/core/convert`'s `convertCurrency`; only the
 *fetch* is component-side. A static fallback table keeps the converter,
 SSR and offline tests working with no network; failures route to an error
-action.
+action. When refreshes overlap, only the newest request may publish success
+or failure; an older completion cannot replace its rates or clear its
+in-flight status.
 
 See `docs/CALC-FORMAT.md` and `ARCHITECTURE.md` for the full contract.
+
+## Exports
+
+Every subpath a consumer can import, derived from the manifest by
+`npm run docs:derive` (`npm run docs:check` fails when the two drift):
+
+<!--fact:exports.calc-->
+| Import | Kind | Declarations |
+|---|---|---|
+| `@jarenjs/calc` | JavaScript | declared |
+| `@jarenjs/calc/component` | JavaScript | declared |
+| `@jarenjs/calc/theme` | JavaScript | declared |
+| `@jarenjs/calc/styles/calc.css` | asset | — |
+| `@jarenjs/calc/schemas/financial-inputs.schema.json` | schema | — |
+| `@jarenjs/calc/schemas/jaren-calc-ast.schema.json` | schema | — |
+| `@jarenjs/calc/schemas/jaren-calc-state.schema.json` | schema | — |
+| `@jarenjs/calc/package.json` | metadata | — |
+<!--/fact-->

package/dist/types/component/index.d.ts

@@ -173,11 +173,56 @@ export declare const calcActions: {
         }[];
     };
     'calc/conv-dim': {
-        patch: {
-            op: string;
-            path: string;
-            value: string;
-        }[];
+        $let: {
+            units: {
+                $if: ({
+                    $for: {
+                        unit: {
+                            $entries: string;
+                        };
+                    };
+                    $return: string;
+                }[] | {
+                    $eq: string[];
+                    $get?: undefined;
+                } | {
+                    $eq?: undefined;
+                    $get: (string | {
+                        $const: {
+                            [k: string]: string[];
+                        };
+                    })[];
+                })[];
+            };
+        };
+        $return: {
+            $if: ({
+                $exists: string;
+                patch?: undefined;
+            } | {
+                $exists?: undefined;
+                patch: ({
+                    op: string;
+                    path: string;
+                    value: string;
+                } | {
+                    op: string;
+                    path: string;
+                    value: {
+                        $if: (string | {
+                            $eq: string[];
+                            $default?: undefined;
+                        } | {
+                            $eq?: undefined;
+                            $default: string[];
+                        })[];
+                    };
+                })[];
+            } | {
+                $exists?: undefined;
+                patch?: undefined;
+            })[];
+        };
     };
     'calc/conv-from': {
         patch: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/calc",
   "private": false,
-  "version": "0.56.0",
+  "version": "0.67.0",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",
@@ -63,9 +63,9 @@
     "prepack": "npm run build:types"
   },
   "dependencies": {
-    "@jarenjs/core": "^0.56.0",
-    "@jarenjs/view": "^0.56.0",
-    "@jarenjs/forms": "^0.56.0",
-    "@jarenjs/app": "^0.56.0"
+    "@jarenjs/core": "^0.67.0",
+    "@jarenjs/view": "^0.67.0",
+    "@jarenjs/forms": "^0.67.0",
+    "@jarenjs/app": "^0.67.0"
   }
 }

package/src/component/index.js

@@ -117,6 +117,12 @@ function keypadFor(mode) {
   }));
 }
 
+/** Static choices come from the converter's unit registry; currency
+ * choices are read from the current rate table by the action. */
+const CONVERTER_UNIT_IDS = Object.fromEntries(converterDimensions()
+  .filter((dimension) => dimension !== 'currency')
+  .map((dimension) => [dimension, unitOptions(dimension).map((unit) => unit.id)]));
+
 /**
  * The action query documents. `dataPointer` for the financial form is
  * `/calc/fin`.
@@ -152,7 +158,29 @@ export const calcActions = {
   'calc/plot-expr': { patch: [{ op: 'replace', path: '/calc/plot/expr', value: '$event.value' }] },
   'calc/plot-kind': { patch: [{ op: 'replace', path: '/calc/plot/kind', value: '$payload.kind' }] },
   // converter
-  'calc/conv-dim': { patch: [{ op: 'replace', path: '/calc/conv/dimension', value: '$event.value' }] },
+  'calc/conv-dim': {
+    $let: { units: { $if: [
+      { $eq: ['$event.value', 'currency'] },
+      [{ $for: { unit: { $entries: '$.calc.rates.rates' } }, $return: '$unit.key' }],
+      { $get: [{ $const: CONVERTER_UNIT_IDS }, '$event.value'] },
+    ] } },
+    // Change the dimension and its unit selections in one transition,
+    // retaining a selection only when the new dimension offers it.
+    $return: { $if: [
+      { $exists: '$units[0]' },
+      { patch: [
+        { op: 'replace', path: '/calc/conv/dimension', value: '$event.value' },
+        { op: 'replace', path: '/calc/conv/from', value: { $if: [
+          { $eq: ['$units[*]', '$.calc.conv.from'] }, '$.calc.conv.from', '$units[0]',
+        ] } },
+        { op: 'replace', path: '/calc/conv/to', value: { $if: [
+          { $eq: ['$units[*]', '$.calc.conv.to'] }, '$.calc.conv.to',
+          { $default: ['$units[1]', '$units[0]'] },
+        ] } },
+      ] },
+      {},
+    ] },
+  },
   'calc/conv-from': { patch: [{ op: 'replace', path: '/calc/conv/from', value: '$event.value' }] },
   'calc/conv-to': { patch: [{ op: 'replace', path: '/calc/conv/to', value: '$event.value' }] },
   'calc/conv-value': { patch: [{ op: 'replace', path: '/calc/conv/value', value: { $number: '$event.value' } }] },

package/src/component/rates/index.js

@@ -70,20 +70,40 @@ export function createRatesLayer(options = {}) {
   const fallbackRates = options.fallbackRates ?? FALLBACK_RATES;
   let lastAt = -Infinity;
   let inflight = false;
+  let generation = 0;
 
   /**
    * Fetch once (debounced), dispatching `calc/rates-ok` or
-   * `calc/rates-err`. `props.force` bypasses the debounce.
+   * `calc/rates-err`. `props.force` bypasses the debounce; only the
+   * newest request may publish a result or clear the in-flight flag.
    */
   function fetchOnce(props, dispatch) {
     const t = now();
     if (!props?.force && (inflight || t - lastAt < refreshMs)) return;
     inflight = true;
     lastAt = t;
-    Promise.resolve(adapter(codes, { fetch: options.fetch, endpoint: options.endpoint, at: t }))
+    const request = ++generation;
+    let result;
+    try {
+      result = adapter(codes, { fetch: options.fetch, endpoint: options.endpoint, at: t });
+    }
+    catch (err) {
+      // A provider may throw before returning its promise. It still
+      // settles through the failure path and releases the in-flight slot.
+      result = Promise.reject(err);
+    }
+    Promise.resolve(result)
       .then(
-        (table) => { inflight = false; dispatch('calc/rates-ok', { ...table, at: t }); },
-        (err) => { inflight = false; dispatch('calc/rates-err', { message: String(err?.message ?? err) }); },
+        (table) => {
+          if (request !== generation) return;
+          inflight = false;
+          dispatch('calc/rates-ok', { ...table, at: t });
+        },
+        (err) => {
+          if (request !== generation) return;
+          inflight = false;
+          dispatch('calc/rates-err', { message: String(err?.message ?? err) });
+        },
       );
   }