@cosmicdrift/kumiko-headless 0.328.0 → 0.328.1

package/dist/locale-routing/index.js

@@ -0,0 +1,143 @@
+function normalizePath(pathname) {
+    if (pathname === "" || pathname === "/")
+        return "/";
+    return pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+}
+function defaultPrefixFor(locale) {
+    return `/${locale}`;
+}
+function stripLocalePrefix(path, locale, prefixFor) {
+    const prefix = prefixFor(locale);
+    if (path === prefix)
+        return "/";
+    if (path.startsWith(`${prefix}/`))
+        return path.slice(prefix.length);
+    return path;
+}
+export function createLocaleRouter(config) {
+    const { defaultLocale, prefixedLocales, routes, localeHints = {}, prefixFor = defaultPrefixFor, homePage = "home", } = config;
+    if (routes[homePage] === undefined) {
+        throw new Error(`locale-routing: homePage "${String(homePage)}" has no entry in routes — altLocalePath's fallback would throw at request time`);
+    }
+    const pathIndex = new Map();
+    for (const [page, localePaths] of Object.entries(routes)) {
+        for (const [locale, routePath] of Object.entries(localePaths)) {
+            pathIndex.set(normalizePath(routePath), { page, locale });
+        }
+    }
+    for (const [hintLocale, hints] of Object.entries(localeHints)) {
+        for (const hint of hints) {
+            const normalizedHint = normalizePath(hint);
+            if (pathIndex.has(normalizedHint))
+                continue;
+            for (const [page, localePaths] of Object.entries(routes)) {
+                const canonical = localePaths[hintLocale];
+                if (canonical === undefined)
+                    continue;
+                const canonicalNorm = normalizePath(canonical);
+                const hintSlug = stripLocalePrefix(normalizedHint, hintLocale, prefixFor);
+                const canonicalSlug = stripLocalePrefix(canonicalNorm, hintLocale, prefixFor);
+                if (hintSlug === canonicalSlug) {
+                    pathIndex.set(normalizedHint, { page, locale: hintLocale });
+                    break;
+                }
+            }
+        }
+    }
+    function detectLang(pathname) {
+        const path = normalizePath(pathname);
+        for (const locale of prefixedLocales) {
+            const prefix = prefixFor(locale);
+            if (path === prefix || path.startsWith(`${prefix}/`))
+                return locale;
+        }
+        const resolved = pathIndex.get(path);
+        if (resolved !== undefined)
+            return resolved.locale;
+        for (const [locale, hints] of Object.entries(localeHints)) {
+            if (hints.some((hint) => normalizePath(hint) === path))
+                return locale;
+        }
+        return defaultLocale;
+    }
+    function resolvePage(pathname) {
+        return pathIndex.get(normalizePath(pathname))?.page;
+    }
+    function publicPath(page, locale) {
+        const localePaths = routes[page];
+        const routePath = localePaths?.[locale];
+        if (localePaths === undefined ||
+            !Object.hasOwn(localePaths, locale) ||
+            routePath === undefined) {
+            throw new Error(`locale-routing: no path for page "${String(page)}" locale "${locale}"`);
+        }
+        return routePath;
+    }
+    function otherLocale(currentLocale) {
+        if (currentLocale === defaultLocale) {
+            return prefixedLocales[0] ?? defaultLocale;
+        }
+        return defaultLocale;
+    }
+    function altLocalePath(pathname, targetLocale) {
+        const path = normalizePath(pathname);
+        const resolved = pathIndex.get(path);
+        const locale = targetLocale ?? otherLocale(detectLang(pathname));
+        if (resolved !== undefined) {
+            return publicPath(resolved.page, locale);
+        }
+        return publicPath(homePage, locale);
+    }
+    function sectionAnchor(page, locale, fragment) {
+        return `${publicPath(page, locale)}#${fragment}`;
+    }
+    return { detectLang, publicPath, resolvePage, altLocalePath, sectionAnchor };
+}
+function defaultBrowserPathname() {
+    const loc = globalThis.location;
+    return typeof loc?.pathname === "string" ? loc.pathname : undefined;
+}
+function defaultSubscribePathname(listener) {
+    const g = globalThis;
+    if (typeof g.addEventListener !== "function" || typeof g.removeEventListener !== "function") {
+        return () => { };
+    }
+    g.addEventListener("popstate", listener);
+    return () => {
+        g.removeEventListener?.("popstate", listener);
+    };
+}
+/**
+ * Prefer URL-derived locale when `resolvePage` matches the current path;
+ * otherwise defer to `base.locale()`. Passes through setLocale and the rest of LocaleResolver.
+ * Without `translateFor`, `base.translate` must already be locale-live.
+ */
+export function wrapUrlLocaleResolver(base, options) {
+    const getPathname = options.pathname ?? defaultBrowserPathname;
+    const subscribePathname = options.subscribePathname ?? defaultSubscribePathname;
+    const resolveLocale = () => {
+        const path = getPathname();
+        if (path === undefined)
+            return base.locale();
+        if (options.resolvePage(path) != null) {
+            return options.detectLang(path);
+        }
+        return base.locale();
+    };
+    return {
+        translate: (key, params) => options.translateFor
+            ? options.translateFor(resolveLocale(), key, params)
+            : base.translate(key, params),
+        timeZone: () => base.timeZone(),
+        subscribe: (listener) => {
+            const unsubBase = base.subscribe(listener);
+            const unsubPath = subscribePathname(listener);
+            return () => {
+                unsubBase();
+                unsubPath();
+            };
+        },
+        setLocale: base.setLocale !== undefined ? (locale) => base.setLocale?.(locale) : undefined,
+        locale: resolveLocale,
+    };
+}

package/dist/nav/index.d.ts

@@ -0,0 +1,2 @@
+export { resolveNavigation } from "./resolve.js";
+export type { NavDefinition, NavNode, NavRegistrySlice, NavTree, ResolveNavigationOptions, } from "./types.js";

package/dist/nav/index.js

@@ -0,0 +1 @@
+export { resolveNavigation } from "./resolve.js";

package/dist/nav/resolve.d.ts

@@ -0,0 +1,2 @@
+import type { NavTree, ResolveNavigationOptions } from "./types.js";
+export declare function resolveNavigation(options: ResolveNavigationOptions): NavTree;

package/dist/nav/resolve.js

@@ -0,0 +1,58 @@
+import { isUiAccessGranted } from "@cosmicdrift/kumiko-framework/ui-types";
+// Assembles the renderable nav tree from the registry's pre-grouped
+// indexes (topLevel + byParent). Walks top-down: each node is
+// access-checked; a hidden parent drops its entire subtree implicitly
+// because we never recurse into it. Siblings sort by `order` (ascending,
+// default 0), tie-broken by qualified name so renders stay deterministic
+// across registry iteration orders.
+//
+// Pure — same inputs produce the same tree. The renderer memoizes the
+// result and only recomputes when the registry changes (rare — boot
+// only) or the user's roles change (logout/login, tenant-switch).
+export function resolveNavigation(options) {
+    const { source, user } = options;
+    function build(entry) {
+        // Shared default-visible UI predicate, not hasAccess from the engine:
+        // that module pulls server-side deps and would break bundle purity.
+        if (!isUiAccessGranted(entry.access, user?.roles))
+            return null;
+        // `entry.id` is already the qualified name — the registry stores
+        // it that way. No reverse-index lookup needed.
+        const children = [];
+        for (const child of source.byParent(entry.id)) {
+            const node = build(child);
+            if (node !== null)
+                children.push(node);
+        }
+        children.sort(bySortKey);
+        return {
+            qualifiedName: entry.id,
+            label: entry.label,
+            order: entry.order ?? 0,
+            children,
+            ...(entry.icon !== undefined && { icon: entry.icon }),
+            ...(entry.screen !== undefined && { screen: entry.screen }),
+            ...(entry.target !== undefined && { target: entry.target }),
+            ...(entry.actions !== undefined && { actions: entry.actions }),
+            ...(entry.createAction !== undefined && { createAction: entry.createAction }),
+            ...(entry.provider !== undefined && { provider: entry.provider }),
+        };
+    }
+    const roots = [];
+    for (const entry of source.topLevel) {
+        const node = build(entry);
+        if (node !== null)
+            roots.push(node);
+    }
+    roots.sort(bySortKey);
+    return roots;
+}
+function bySortKey(a, b) {
+    // Primary key: `order` ascending. Secondary: qualifiedName alphabetic,
+    // which is a stable fallback — the registry-iteration order isn't
+    // guaranteed across boots, so tied-order entries would otherwise
+    // shuffle between renders.
+    if (a.order !== b.order)
+        return a.order - b.order;
+    return a.qualifiedName.localeCompare(b.qualifiedName);
+}

package/dist/nav/types.d.ts

@@ -0,0 +1,26 @@
+import type { NavDefinition, TargetRef, TreeAction } from "@cosmicdrift/kumiko-framework/ui-types";
+export type NavNode = {
+    readonly qualifiedName: string;
+    readonly label: string;
+    readonly icon?: string;
+    readonly screen?: string;
+    readonly target?: TargetRef;
+    readonly actions?: readonly TreeAction[];
+    readonly createAction?: TreeAction;
+    readonly provider?: boolean;
+    readonly order: number;
+    readonly children: readonly NavNode[];
+};
+export type NavTree = readonly NavNode[];
+export type NavRegistrySlice = {
+    readonly topLevel: readonly NavDefinition[];
+    readonly byParent: (parentQualifiedName: string) => readonly NavDefinition[];
+};
+export type ResolveNavigationOptions = {
+    readonly source: NavRegistrySlice;
+    readonly user?: {
+        readonly id: string;
+        readonly roles: readonly string[];
+    };
+};
+export type { NavDefinition };

package/dist/nav/types.js

@@ -0,0 +1 @@
+export {};

package/dist/store/create-store.d.ts

@@ -0,0 +1,2 @@
+import type { WritableStore } from "./types.js";
+export declare function createStore<T>(initial: T): WritableStore<T>;

package/{src/store/create-store.ts → dist/store/create-store.js}

@@ -1,5 +1,3 @@
-import type { WritableStore } from "./types";
-
 // Subscribe/Emit primitive matching React's useSyncExternalStore.
 // Single canonical implementation — every stateful controller in
 // ui-core/renderer land composes on top of this instead of rolling
@@ -21,25 +19,25 @@ import type { WritableStore } from "./types";
 //   store.setState(() => myNewFn);
 // In practice, function-valued stores are rare — feature controllers
 // hold values, not callbacks.
-
-export function createStore<T>(initial: T): WritableStore<T> {
-  let snapshot = initial;
-  const listeners = new Set<() => void>();
-
-  return {
-    getSnapshot: () => snapshot,
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    setState: (next) => {
-      const nextValue = typeof next === "function" ? (next as (prev: T) => T)(snapshot) : next;
-      // skip: next value identical to snapshot, avoid notifying listeners
-      if (Object.is(nextValue, snapshot)) return;
-      snapshot = nextValue;
-      for (const listener of listeners) listener();
-    },
-  };
+export function createStore(initial) {
+    let snapshot = initial;
+    const listeners = new Set();
+    return {
+        getSnapshot: () => snapshot,
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        setState: (next) => {
+            const nextValue = typeof next === "function" ? next(snapshot) : next;
+            // skip: next value identical to snapshot, avoid notifying listeners
+            if (Object.is(nextValue, snapshot))
+                return;
+            snapshot = nextValue;
+            for (const listener of listeners)
+                listener();
+        },
+    };
 }

package/dist/store/equality.d.ts

@@ -0,0 +1 @@
+export declare function shallowEqual(a: unknown, b: unknown): boolean;

package/{src/store/equality.ts → dist/store/equality.js}

@@ -7,28 +7,30 @@
 // Mirrors Zustand's `shallow` and react-redux's `shallowEqual` — same
 //8-line shape, no recursion. Apps that need deep equality reach for
 // their own helper.
-
 // Signature is `(a: unknown, b: unknown)` not `<T>(a: T, b: T)` because the
 // function legitimately compares cross-type values (primitive vs. object,
 // null vs. {}, etc.) and returns false for mismatches. A generic `<T>`
 // would force callers into type-gymnastics for those cases. Contra-variance
 // ensures this still satisfies `(a: S, b: S) => boolean` slots like
 // useStoreSelector's `equals` arg.
-export function shallowEqual(a: unknown, b: unknown): boolean {
-  if (Object.is(a, b)) return true;
-  if (typeof a !== "object" || a === null) return false;
-  if (typeof b !== "object" || b === null) return false;
-
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) return false;
-
-  for (const key of keysA) {
-    if (!Object.hasOwn(b, key)) return false;
-    if (!Object.is((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key])) {
-      // @cast-boundary generic-record
-      return false;
+export function shallowEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== "object" || a === null)
+        return false;
+    if (typeof b !== "object" || b === null)
+        return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        if (!Object.hasOwn(b, key))
+            return false;
+        if (!Object.is(a[key], b[key])) {
+            // @cast-boundary generic-record
+            return false;
+        }
     }
-  }
-  return true;
+    return true;
 }

package/dist/store/index.d.ts

@@ -0,0 +1,3 @@
+export { createStore } from "./create-store.js";
+export { shallowEqual } from "./equality.js";
+export type { Store, WritableStore } from "./types.js";

package/dist/store/index.js

@@ -0,0 +1,2 @@
+export { createStore } from "./create-store.js";
+export { shallowEqual } from "./equality.js";

package/dist/store/types.d.ts

@@ -0,0 +1,7 @@
+export type Store<T> = {
+    getSnapshot(): T;
+    subscribe(listener: () => void): () => void;
+};
+export type WritableStore<T> = Store<T> & {
+    setState(next: T | ((prev: T) => T)): void;
+};

package/dist/store/types.js

@@ -0,0 +1,10 @@
+// Store contract — Pull-Style Subscribe/Emit matching React's
+// useSyncExternalStore signature. The single canonical shape for
+// every stateful controller in ui-core/renderer land (form,
+// dispatcher-status, locale, token, nav, lifecycle).
+//
+// Rationale in docs/plans/ui-store.md. Not a new state-management
+// decision — ui-decisions.md already picked Subscribe/Emit; this
+// module just materializes the pattern instead of rolling a new
+// Set<() => void> per controller.
+export {};

package/dist/view-model/edit.d.ts

@@ -0,0 +1,10 @@
+import type { EntityDefinition, EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { EditViewModel, Translate } from "./types.js";
+export type ComputeEditViewModelInput<TValues extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> = {
+    readonly screen: EntityEditScreenDefinition;
+    readonly entity: EntityDefinition;
+    readonly values: TValues;
+    readonly translate: Translate;
+    readonly featureName: string;
+};
+export declare function computeEditViewModel<TValues extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>>(input: ComputeEditViewModelInput<TValues>): EditViewModel;