@krapwoo/ds-viewer 0.14.2 → 0.15.0

package/dist/cli/tokenDefinition.js

@@ -0,0 +1,125 @@
+/**
+ * Static, literal-only reader for `CatalogPageInput.tokenDefinition` — the same posture
+ * `cli/staticPage.ts`'s own `readStaticPage` already uses for every other field: no module
+ * resolution, no execution, a same-file `const` chase only (`resolve`, reused from
+ * `cli/staticPage.ts`). Reads structural metadata only (`kind`, section `id`/`title`/`desc`/`wide`,
+ * and each entry's own literal `id`, for duplicate detection) — never an entry's real value, which
+ * stays an opaque runtime import (design R4).
+ */
+import * as ts from 'typescript';
+import { findProp, propertyStringLiteral, readStringLiteralArray, resolve } from "./staticPage.js";
+import { canonicalTokenTitle, isTokenKind } from "../native/catalog/tokenDefinition.js";
+/** Reads `node` (a `tokenDefinition:` property initializer) down to `kind` and each section's
+ *  `id`/`title`/`desc`/`wide`/entry-ids. Returns `undefined` — never a partial read — when `kind`
+ *  isn't a literal, `sections` isn't a literal array, or any one section isn't a literal object
+ *  with a literal `id` and `title`: the same "never a partial read" contract every other array
+ *  reader in `cli/staticPage.ts` already follows (`readComposedOf`, `readSections`, …). An entry
+ *  whose own `id` isn't literal is simply omitted from `entryIds` — informational leniency, since
+ *  only the *structural* shape (kind/sections/ids) needs to be checkable, never an entry's real
+ *  value (design R4: "no blanket uncheckability of otherwise literal page geometry"). */
+export function readStaticTokenDefinition(node, consts) {
+    const resolved = resolve(node, consts, new Set());
+    if (!ts.isObjectLiteralExpression(resolved))
+        return undefined;
+    const kind = propertyStringLiteral(resolved, 'kind', consts);
+    if (kind === undefined)
+        return undefined;
+    const sectionsProp = findProp(resolved, 'sections');
+    if (!sectionsProp)
+        return undefined;
+    const sectionsResolved = resolve(sectionsProp.initializer, consts, new Set());
+    if (!ts.isArrayLiteralExpression(sectionsResolved))
+        return undefined;
+    const sections = [];
+    for (const element of sectionsResolved.elements) {
+        const sectionResolved = resolve(element, consts, new Set());
+        if (!ts.isObjectLiteralExpression(sectionResolved))
+            return undefined;
+        const id = propertyStringLiteral(sectionResolved, 'id', consts);
+        const title = propertyStringLiteral(sectionResolved, 'title', consts);
+        if (id === undefined || title === undefined)
+            return undefined;
+        const desc = propertyStringLiteral(sectionResolved, 'desc', consts);
+        const wideProp = findProp(sectionResolved, 'wide');
+        const wide = wideProp ? resolve(wideProp.initializer, consts, new Set()).kind === ts.SyntaxKind.TrueKeyword : false;
+        const entryIds = [];
+        let entriesOpaque = false;
+        const entriesProp = findProp(sectionResolved, 'entries');
+        if (entriesProp) {
+            const entriesResolved = resolve(entriesProp.initializer, consts, new Set());
+            if (ts.isArrayLiteralExpression(entriesResolved)) {
+                for (const entryElement of entriesResolved.elements) {
+                    const entryResolved = resolve(entryElement, consts, new Set());
+                    if (!ts.isObjectLiteralExpression(entryResolved)) {
+                        entriesOpaque = true;
+                        continue;
+                    }
+                    const entryId = propertyStringLiteral(entryResolved, 'id', consts);
+                    if (entryId !== undefined)
+                        entryIds.push(entryId);
+                    else
+                        entriesOpaque = true;
+                }
+            }
+            else {
+                entriesOpaque = true;
+            }
+        }
+        // #64 B1: this section's own sub-groups, read the same lenient way as its own entries above.
+        const groups = [];
+        let groupsOpaque = false;
+        const groupsProp = findProp(sectionResolved, 'groups');
+        if (groupsProp) {
+            const groupsResolved = resolve(groupsProp.initializer, consts, new Set());
+            if (ts.isArrayLiteralExpression(groupsResolved)) {
+                for (const groupElement of groupsResolved.elements) {
+                    const groupResolved = resolve(groupElement, consts, new Set());
+                    if (!ts.isObjectLiteralExpression(groupResolved)) {
+                        groupsOpaque = true;
+                        continue;
+                    }
+                    const groupId = propertyStringLiteral(groupResolved, 'id', consts);
+                    const groupTitle = propertyStringLiteral(groupResolved, 'title', consts);
+                    if (groupId === undefined || groupTitle === undefined) {
+                        groupsOpaque = true;
+                        continue;
+                    }
+                    const groupEntryIds = [];
+                    let groupEntriesOpaque = false;
+                    const groupEntriesProp = findProp(groupResolved, 'entries');
+                    if (groupEntriesProp) {
+                        const groupEntriesResolved = resolve(groupEntriesProp.initializer, consts, new Set());
+                        if (ts.isArrayLiteralExpression(groupEntriesResolved)) {
+                            for (const entryElement of groupEntriesResolved.elements) {
+                                const entryResolved = resolve(entryElement, consts, new Set());
+                                if (!ts.isObjectLiteralExpression(entryResolved)) {
+                                    groupEntriesOpaque = true;
+                                    continue;
+                                }
+                                const entryId = propertyStringLiteral(entryResolved, 'id', consts);
+                                if (entryId !== undefined)
+                                    groupEntryIds.push(entryId);
+                                else
+                                    groupEntriesOpaque = true;
+                            }
+                        }
+                        else {
+                            groupEntriesOpaque = true;
+                        }
+                    }
+                    groups.push({ id: groupId, title: groupTitle, entryIds: groupEntryIds, entriesOpaque: groupEntriesOpaque });
+                }
+            }
+            else {
+                groupsOpaque = true;
+            }
+        }
+        // #64 B5: this section's own literal `aliases`, when every element resolves as a literal
+        // string — omitted (never a penalty) otherwise.
+        const aliasesProp = findProp(sectionResolved, 'aliases');
+        const aliases = aliasesProp ? readStringLiteralArray(aliasesProp.initializer, consts) : undefined;
+        sections.push({ id, title, desc, wide, entryIds, entriesOpaque, groups, groupsOpaque, ...(aliases !== undefined ? { aliases } : null) });
+    }
+    return { kind, sections };
+}
+export { canonicalTokenTitle, isTokenKind };

package/dist/native/catalog/catalogNavigation.js

@@ -132,23 +132,37 @@ export function resolveActiveFromHash(hash, order) {
     return idFromHash(hash, order);
 }
 /** Every member id other than the whole, every member alias, and every family page's own
- *  (page-level) alias, mapped to where it resolves (spec §5.3 "Old addresses"). Pages without a
- *  `family` contribute nothing. */
+ *  (page-level) alias, mapped to where it resolves (spec §5.3 "Old addresses"). #64 B5: also, a
+ *  tokenDefinition page's own page-level aliases (`tokenDefinitionAliases`) and each of its
+ *  sections' own `aliases` — the same routing a family page's aliases already get, extended to
+ *  tokenDefinition pages. A page with neither contributes nothing. */
 export function aliasTargets(sections) {
     const targets = new Map();
     for (const section of sections) {
         const family = section.family;
-        if (!family)
-            continue;
-        for (const member of family.members) {
-            if (member.id === family.whole)
-                continue;
-            targets.set(member.id, { pageId: section.id, memberId: member.id });
-            for (const alias of member.aliases ?? [])
-                targets.set(alias, { pageId: section.id, memberId: member.id });
+        if (family) {
+            for (const member of family.members) {
+                if (member.id === family.whole) {
+                    // C3: the whole's own id already resolves via `order` (it equals the page's own id), but
+                    // its own aliases were never registered anywhere — routing one to the page, with no member
+                    // focus (unlike a non-whole member's alias, which focuses that member).
+                    for (const alias of member.aliases ?? [])
+                        targets.set(alias, { pageId: section.id });
+                    continue;
+                }
+                targets.set(member.id, { pageId: section.id, memberId: member.id });
+                for (const alias of member.aliases ?? [])
+                    targets.set(alias, { pageId: section.id, memberId: member.id });
+            }
+            for (const alias of family.aliases ?? [])
+                targets.set(alias, { pageId: section.id });
         }
-        for (const alias of family.aliases ?? [])
+        for (const alias of section.tokenDefinitionAliases ?? [])
             targets.set(alias, { pageId: section.id });
+        for (const tdSection of section.tokenDefinition?.sections ?? []) {
+            for (const alias of tdSection.aliases ?? [])
+                targets.set(alias, { pageId: section.id, sectionId: tdSection.id });
+        }
     }
     return targets;
 }
@@ -171,6 +185,8 @@ export function resolveRoute(hash, order, aliases) {
     if (target) {
         if (target.memberId !== undefined)
             return { kind: 'member', pageId: target.pageId, memberId: target.memberId };
+        if (target.sectionId !== undefined)
+            return { kind: 'page', id: target.pageId, sectionId: target.sectionId };
         return { kind: 'page', id: target.pageId };
     }
     return { kind: 'notFound', raw: decoded };