@fusion.dev/helix-core 0.176.0 → 0.176.1

package/custom-elements.json

@@ -33810,7 +33810,7 @@
           "type": {
             "text": "string"
           },
-          "default": "'0.176.0'",
+          "default": "'0.176.1'",
           "description": "The version of the package this file ships in.\n\n**Written by `fusion/scripts/version.mjs`** wherever it writes the package's\n`package.json`, and stamped back into the repository beside it after a\nrelease, so the two never disagree; a spec beside this holds them to it.\nNothing else in the running code knows which release it is."
         }
       ],
@@ -33825,6 +33825,110 @@
         }
       ]
     },
+    {
+      "kind": "javascript-module",
+      "path": "src/words/held.ts",
+      "declarations": [
+        {
+          "kind": "variable",
+          "name": "held",
+          "type": {
+            "text": "Held"
+          },
+          "description": "The page's words, held on `globalThis`.\n\n**One registry for a page that carries two copies of this module**, one per\nbundle that imports it: words registered through one have to reach elements\ndefined through the other, as the icon registry's glyphs do.\n\n**What every element reads, and nothing more.** An element with a word\nproperty reads its English until a page registers words, so the lookup and\nthe locale chain arrive with `registerWords`, which puts its lookup in\n`find`, and the locale with `wordsLocale`, which puts itself in `locale`. A\npage that registers no words and formats no numbers ships neither: measured\non Button, 474 bytes of its 13,437 compressed."
+        },
+        {
+          "kind": "function",
+          "name": "changed",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "description": "Asks every element that reads words to look again, once per task."
+        },
+        {
+          "kind": "function",
+          "name": "wordsRegistered",
+          "return": {
+            "type": {
+              "text": "boolean"
+            }
+          },
+          "description": "Whether any words are registered, for a read that can skip the lookup."
+        },
+        {
+          "kind": "function",
+          "name": "watchLang",
+          "return": {
+            "type": {
+              "text": "void"
+            }
+          },
+          "description": "Starts watching the document's `lang`, once for the page, in a browser.\nCalled by what a `lang` change reaches: registered words, and a locale read."
+        },
+        {
+          "kind": "function",
+          "name": "watchWords",
+          "return": {
+            "type": {
+              "text": "(() => void)"
+            }
+          },
+          "parameters": [
+            {
+              "name": "watcher",
+              "type": {
+                "text": "() => void"
+              }
+            }
+          ],
+          "description": "Calls `watcher` once in the microtask after words are registered or\ncleared, or the document's `lang` changes. Returns the function that stops\nit."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "held",
+          "declaration": {
+            "name": "held",
+            "module": "src/words/held.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "changed",
+          "declaration": {
+            "name": "changed",
+            "module": "src/words/held.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "wordsRegistered",
+          "declaration": {
+            "name": "wordsRegistered",
+            "module": "src/words/held.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "watchLang",
+          "declaration": {
+            "name": "watchLang",
+            "module": "src/words/held.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "watchWords",
+          "declaration": {
+            "name": "watchWords",
+            "module": "src/words/held.ts"
+          }
+        }
+      ]
+    },
     {
       "kind": "javascript-module",
       "path": "src/words/index.ts",
@@ -34094,16 +34198,6 @@
           ],
           "description": "The locales a word is looked for in, most specific first, ending in `en`.\n\n**The script comes before the bare language**, so Hong Kong (`zh-HK`)\nreaches a Traditional Chinese pack (`zh-Hant`) before a `zh` pack, which is\nusually Simplified. Unicode extensions are dropped, and a tag `Intl` refuses\nfalls straight to `en`.\n\n`de-CH` tries `de-ch`, `de-latn-ch`, `de-latn`, `de`, then `en`."
         },
-        {
-          "kind": "function",
-          "name": "wordsRegistered",
-          "return": {
-            "type": {
-              "text": "boolean"
-            }
-          },
-          "description": "Whether any words are registered, for a read that can skip the lookup."
-        },
         {
           "kind": "function",
           "name": "lookupWord",
@@ -34133,27 +34227,25 @@
             }
           ],
           "description": "A registered word for a tag's property in a locale, with the locale it was\nfound in, or `undefined`.\n\n**Per key, along the chain.** A `de-CH` pack that holds only the Swiss\nspellings falls through to `de` for every other word. A word table merges\nalong the chain, the more specific entry winning."
-        },
-        {
-          "kind": "function",
-          "name": "watchWords",
-          "return": {
-            "type": {
-              "text": "(() => void)"
-            }
-          },
-          "parameters": [
-            {
-              "name": "watcher",
-              "type": {
-                "text": "() => void"
-              }
-            }
-          ],
-          "description": "Calls `watcher` once in the microtask after words are registered or\ncleared, or the document's `lang` changes. Returns the function that stops\nit.\n\nThe first watcher in a browser starts watching the document's `lang`, once\nfor the page."
         }
       ],
       "exports": [
+        {
+          "kind": "js",
+          "name": "watchWords",
+          "declaration": {
+            "name": "watchWords",
+            "module": "./held.js"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "wordsRegistered",
+          "declaration": {
+            "name": "wordsRegistered",
+            "module": "./held.js"
+          }
+        },
         {
           "kind": "js",
           "name": "registerWords",
@@ -34202,14 +34294,6 @@
             "module": "src/words/registry.ts"
           }
         },
-        {
-          "kind": "js",
-          "name": "wordsRegistered",
-          "declaration": {
-            "name": "wordsRegistered",
-            "module": "src/words/registry.ts"
-          }
-        },
         {
           "kind": "js",
           "name": "lookupWord",
@@ -34217,14 +34301,6 @@
             "name": "lookupWord",
             "module": "src/words/registry.ts"
           }
-        },
-        {
-          "kind": "js",
-          "name": "watchWords",
-          "declaration": {
-            "name": "watchWords",
-            "module": "src/words/registry.ts"
-          }
         }
       ]
     },
@@ -34370,6 +34446,6 @@
   ],
   "helix": {
     "package": "@fusion.dev/helix-core",
-    "version": "0.176.0"
+    "version": "0.176.1"
   }
 }

package/dist/version.d.ts

@@ -6,4 +6,4 @@
  * release, so the two never disagree; a spec beside this holds them to it.
  * Nothing else in the running code knows which release it is.
  */
-export declare const VERSION = "0.176.0";
+export declare const VERSION = "0.176.1";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.176.0';
+export const VERSION = '0.176.1';

package/dist/words/held.d.ts

@@ -0,0 +1,55 @@
+import type { Message, MessageTable } from './message.js';
+/** One locale's words, by tag, then by property. */
+export type Pack = Record<string, Record<string, Message | MessageTable>>;
+/** An element that reads words, perhaps with a `locale`. */
+export type Speaker = Element & {
+    locale?: string | undefined;
+};
+/** What the page has registered, kept on `globalThis`. */
+interface Held {
+    /** Each locale's words, under its lowercase tag. */
+    packs: Map<string, Pack>;
+    /** The locale a server render and a hydrating render speak. */
+    fallback: string;
+    /** What updates the elements that read words. */
+    watchers: Set<() => void>;
+    /** Whether an update is already queued for this task. */
+    queued?: boolean;
+    /** Whether the document's `lang` is watched. */
+    observed?: boolean;
+    /** Finds a registered word for an element, set by the first `registerWords`. */
+    find?: (host: Speaker, tag: string, name: string) => [Message | MessageTable, string] | undefined;
+    /** Reads the locale an element speaks, set where `wordsLocale` is loaded. */
+    locale?: (host: Speaker) => string;
+}
+/**
+ * The page's words, held on `globalThis`.
+ *
+ * **One registry for a page that carries two copies of this module**, one per
+ * bundle that imports it: words registered through one have to reach elements
+ * defined through the other, as the icon registry's glyphs do.
+ *
+ * **What every element reads, and nothing more.** An element with a word
+ * property reads its English until a page registers words, so the lookup and
+ * the locale chain arrive with `registerWords`, which puts its lookup in
+ * `find`, and the locale with `wordsLocale`, which puts itself in `locale`. A
+ * page that registers no words and formats no numbers ships neither: measured
+ * on Button, 474 bytes of its 13,437 compressed.
+ */
+export declare const held: Held;
+/** Asks every element that reads words to look again, once per task. */
+export declare const changed: () => void;
+/** Whether any words are registered, for a read that can skip the lookup. */
+export declare const wordsRegistered: () => boolean;
+/**
+ * Starts watching the document's `lang`, once for the page, in a browser.
+ * Called by what a `lang` change reaches: registered words, and a locale read.
+ */
+export declare const watchLang: () => void;
+/**
+ * Calls `watcher` once in the microtask after words are registered or
+ * cleared, or the document's `lang` changes. Returns the function that stops
+ * it.
+ */
+export declare const watchWords: (watcher: () => void) => (() => void);
+export {};

package/dist/words/held.js

@@ -0,0 +1,29 @@
+export const held = (globalThis[Symbol.for('helix.words')] ??= {
+    fallback: 'en',
+    packs: new Map(),
+    watchers: new Set(),
+});
+export const changed = () => {
+    if (!held.queued) {
+        held.queued = true;
+        queueMicrotask(() => {
+            held.queued = false;
+            for (const watcher of held.watchers) {
+                watcher();
+            }
+        });
+    }
+};
+export const wordsRegistered = () => held.packs.size > 0;
+export const watchLang = () => {
+    if (!held.observed && typeof MutationObserver === 'function' && globalThis.document) {
+        held.observed = true;
+        new MutationObserver(changed).observe(document.documentElement, {
+            attributeFilter: ['lang'],
+        });
+    }
+};
+export const watchWords = (watcher) => {
+    held.watchers.add(watcher);
+    return () => held.watchers.delete(watcher);
+};

package/dist/words/registry.d.ts

@@ -1,4 +1,5 @@
 import type { Message, MessageTable } from './message.js';
+export { watchWords, wordsRegistered } from './held.js';
 /**
  * The words of every family, keyed by the family's styled tag, each with its
  * word properties.
@@ -67,8 +68,6 @@ export declare const refreshWords: () => void;
  * `de-CH` tries `de-ch`, `de-latn-ch`, `de-latn`, `de`, then `en`.
  */
 export declare const localeChain: (locale: string) => string[];
-/** Whether any words are registered, for a read that can skip the lookup. */
-export declare const wordsRegistered: () => boolean;
 /**
  * A registered word for a tag's property in a locale, with the locale it was
  * found in, or `undefined`.
@@ -78,12 +77,3 @@ export declare const wordsRegistered: () => boolean;
  * along the chain, the more specific entry winning.
  */
 export declare const lookupWord: (locale: string, tag: string, name: string) => [Message | MessageTable, string] | undefined;
-/**
- * Calls `watcher` once in the microtask after words are registered or
- * cleared, or the document's `lang` changes. Returns the function that stops
- * it.
- *
- * The first watcher in a browser starts watching the document's `lang`, once
- * for the page.
- */
-export declare const watchWords: (watcher: () => void) => (() => void);

package/dist/words/registry.js

@@ -1,20 +1,9 @@
-const held = (globalThis[Symbol.for('helix.words')] ??= {
-    fallback: 'en',
-    packs: new Map(),
-    watchers: new Set(),
-});
-const changed = () => {
-    if (!held.queued) {
-        held.queued = true;
-        queueMicrotask(() => {
-            held.queued = false;
-            for (const watcher of held.watchers) {
-                watcher();
-            }
-        });
-    }
-};
+import { changed, held, watchLang } from './held.js';
+import { wordsLocale } from './words-locale.js';
+export { watchWords, wordsRegistered } from './held.js';
 export const registerWords = (locale, ...words) => {
+    held.find ??= (host, tag, name) => lookupWord(wordsLocale(host), tag, name);
+    watchLang();
     const key = locale.toLowerCase();
     const pack = held.packs.get(key) ?? {};
     held.packs.set(key, pack);
@@ -74,7 +63,6 @@ export const localeChain = (locale) => {
     chains.set(locale, found);
     return found;
 };
-export const wordsRegistered = () => held.packs.size > 0;
 export const lookupWord = (locale, tag, name) => {
     let found;
     for (const one of localeChain(locale)) {
@@ -89,13 +77,3 @@ export const lookupWord = (locale, tag, name) => {
     }
     return found;
 };
-export const watchWords = (watcher) => {
-    held.watchers.add(watcher);
-    if (!held.observed && typeof MutationObserver === 'function' && globalThis.document) {
-        held.observed = true;
-        new MutationObserver(changed).observe(document.documentElement, {
-            attributeFilter: ['lang'],
-        });
-    }
-    return () => held.watchers.delete(watcher);
-};

package/dist/words/words-locale.js

@@ -1,5 +1,5 @@
 import { localeOf, runtimeLocale } from '../utils/locale-of/locale-of.js';
-import { defaultWordsLocale } from './registry.js';
+import { held, watchLang } from './held.js';
 const checked = new Map();
 const tagOf = (written) => {
     let found = checked.get(written);
@@ -15,15 +15,17 @@ const tagOf = (written) => {
     return found;
 };
 export const wordsLocale = (element) => {
+    watchLang();
     const own = tagOf(element.locale || '');
     if (own) {
         return own;
     }
     if (typeof element.closest !== 'function' || element.hydrating) {
-        return tagOf(element.getAttribute?.('lang') ?? '') || defaultWordsLocale();
+        return tagOf(element.getAttribute?.('lang') ?? '') || held.fallback;
     }
     return localeOf(element) || runtimeLocale();
 };
+held.locale = wordsLocale;
 export const handedLocale = (element) => {
     const own = typeof element.locale === 'string' ? element.locale : '';
     return element.hydrating ? own : localeOf(element, own);

package/dist/words/words.js

@@ -1,5 +1,5 @@
+import { held, watchWords, wordsRegistered } from './held.js';
 import { formatMessage } from './message.js';
-import { lookupWord, watchWords, wordsRegistered } from './registry.js';
 import { wordsLocale } from './words-locale.js';
 const HELD = Symbol();
 const heldBy = (host) => host[HELD] ?? {};
@@ -21,7 +21,7 @@ const resolve = (host, name) => {
     let found = [own, ''];
     if (own == null || table) {
         const registered = wordsRegistered()
-            ? lookupWord(wordsLocale(host), host.constructor.words || host.localName, name)
+            ? held.find?.(host, host.constructor.words || host.localName, name)
             : undefined;
         found = table
             ? [{ ...table, ...registered?.[0], ...own }, '']
@@ -44,10 +44,10 @@ const watcher = (host) => {
     let locale = '';
     return {
         hostConnected: () => {
-            locale = wordsLocale(host);
+            locale = held.locale?.(host) ?? '';
             stop = watchWords(() => {
                 recheck(host);
-                const now = wordsLocale(host);
+                const now = held.locale?.(host) ?? '';
                 if (now !== locale) {
                     locale = now;
                     host.requestUpdate();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-core",
   "description": "Helix element primitives: base classes, mixins, decorators, utilities.",
-  "version": "0.176.0",
+  "version": "0.176.1",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -62,11 +62,11 @@
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
     "@floating-ui/dom": "^1.8.0",
-    "@fusion.dev/helix-icons": "0.176.0"
+    "@fusion.dev/helix-icons": "0.176.1"
   },
   "devDependencies": {
-    "@fusion.dev/helix-cem": "0.176.0",
-    "@fusion.dev/helix-testing": "0.176.0",
+    "@fusion.dev/helix-cem": "0.176.1",
+    "@fusion.dev/helix-testing": "0.176.1",
     "@lit-labs/ssr": "^4.1.0",
     "lit": "^3.2.1"
   },