@almadar/shell-web 0.0.0-stage → 1.0.0

package/bundling.d.mts

@@ -0,0 +1,18 @@
+/** What `keepDynamicImportsLazy` reads of Rollup's module graph. */
+export interface BundlingModuleInfo {
+  isEntry: boolean;
+  /** Static importers only (Rollup lists dynamic ones separately). */
+  importers: readonly string[];
+}
+
+export interface BundlingChunkMeta {
+  getModuleInfo(id: string): BundlingModuleInfo | null;
+}
+
+/**
+ * Wraps an app's `manualChunks` rule: a module goes to the named chunk only when an entry reaches
+ * it through static imports, so @almadar/ui's lazily imported families stay lazy.
+ */
+export declare function keepDynamicImportsLazy(
+  assign: (id: string) => string | null | undefined,
+): (id: string, meta: BundlingChunkMeta) => string | null | undefined;

package/bundling.mjs

@@ -0,0 +1,28 @@
+/**
+ * Build-time helper for apps bundling @almadar/ui. The ui loads heavy families lazily (mermaid
+ * and what it pulls, leaflet, …) through dynamic import(); an app's catch-all `manualChunks`
+ * would move them into its eagerly loaded vendor chunk. Wrap it: a module goes to the named
+ * chunk only when an entry reaches it through static imports.
+ */
+export function keepDynamicImportsLazy(assign) {
+  const memo = new WeakMap();
+  return (id, meta) => {
+    const name = assign(id);
+    if (!name) return name;
+    let known = memo.get(meta.getModuleInfo);
+    if (!known) {
+      known = new Map();
+      memo.set(meta.getModuleInfo, known);
+    }
+    return staticallyReachable(id, meta.getModuleInfo, known) ? name : undefined;
+  };
+}
+
+function staticallyReachable(id, getModuleInfo, known) {
+  if (known.has(id)) return known.get(id);
+  known.set(id, false); // in progress: a cycle does not reach an entry by itself
+  const info = getModuleInfo(id);
+  const reachable = info === null || info.isEntry || info.importers.some((importer) => staticallyReachable(importer, getModuleInfo, known));
+  known.set(id, reachable);
+  return reachable;
+}

package/dist/ArbitraryClassCompiler-CO_iASBn.d.ts

@@ -0,0 +1,195 @@
+import * as React from 'react';
+import React__default, { ReactNode, ReactElement } from 'react';
+import { ThemeRef, UserContext as UserContext$1, FieldValue, OrbitalSchema } from '@almadar/core';
+import './EventBusProvider-BFFHfN4O.js';
+import { T as ThemeProviderProps } from './ThemeContext-DJmO59xd.js';
+
+/**
+ * OrbitalThemeProvider — runtime application of `OrbitalDefinition.theme`.
+ *
+ * Wraps an orbital's rendered subtree in a surface `Box` that sets the
+ * CSS variables derived from `theme.tokens` (and `variants.dark` when the
+ * resolved color mode is dark). Inline custom-property declarations on the
+ * wrapper override any `[data-theme]` selector rule for the same variable
+ * within the subtree, while letting unset variables cascade from the parent.
+ *
+ * Mapping is delegated to `themeTokensToCssVars`, which mirrors the Rust
+ * compiler's `generate_tokens_css`. Compile-time and runtime produce the
+ * same CSS variable map for the same `ThemeDefinition` input, so a Studio
+ * Design System edit and an `orbital compile` of the same schema render
+ * identically.
+ *
+ * A registry theme key (e.g. `"gazette-light"`) scopes that preset to the
+ * subtree through `data-theme` on a wrapper that paints the theme's
+ * background, so an orbital renders in its declared theme even inside a host
+ * document running another one (playground picker, runtime-verify catalog).
+ *
+ * No-op when:
+ * - `theme` is `undefined` (orbital declares no theme — parent cascades)
+ * - `theme` is the legacy `"Alias.theme"` import form that didn't get inlined upstream
+ *
+ * @example
+ * ```tsx
+ * <OrbitalThemeProvider theme={orbital.theme}>
+ *   <UISlotRenderer />
+ * </OrbitalThemeProvider>
+ * ```
+ */
+
+interface OrbitalThemeProviderProps {
+    /** The `OrbitalDefinition.theme` value (inline definition or string ref). */
+    theme?: ThemeRef;
+    /**
+     * A host's explicit theme pick (registry key, e.g. the playground picker).
+     * Replaces `theme` here, in every nested orbital scope, and on every
+     * `data-theme` a component declares inside (see `ThemeScope.override`).
+     */
+    override?: string;
+    children: ReactNode;
+}
+declare function OrbitalThemeProvider({ theme: declared, override, children }: OrbitalThemeProviderProps): ReactElement;
+declare namespace OrbitalThemeProvider {
+    var displayName: string;
+}
+
+/**
+ * @deprecated Use ThemeProvider from ThemeContext instead
+ */
+declare const DesignThemeProvider: React.FC<ThemeProviderProps>;
+/**
+ * @deprecated Use useTheme from ThemeContext instead
+ *
+ * This wrapper provides backward compatibility with the old API.
+ */
+declare function useDesignTheme(): {
+    designTheme: string;
+    setDesignTheme: (theme: string) => void;
+    availableThemes: string[];
+};
+
+declare const CurrentPagePathContext: React__default.Context<string | undefined>;
+interface CurrentPagePathProviderProps {
+    value: string | undefined;
+    children: React__default.ReactNode;
+}
+declare const CurrentPagePathProvider: React__default.FC<CurrentPagePathProviderProps>;
+declare const useCurrentPagePath: () => string | undefined;
+
+/**
+ * UserContext
+ *
+ * React context for providing user data throughout the application.
+ * Enables @user bindings in S-expressions for role-based UI and permissions.
+ *
+ * Usage:
+ * ```tsx
+ * // In App.tsx or layout
+ * <UserProvider user={{ id: '123', role: 'admin', permissions: ['read', 'write'] }}>
+ *   <App />
+ * </UserProvider>
+ *
+ * // In components - access via hook
+ * const { user, hasRole, hasPermission } = useUser();
+ * if (hasRole('admin')) { ... }
+ * if (hasPermission('delete')) { ... }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * User data for `@user` bindings — the canonical `UserContext` from
+ * `@almadar/core`, kept under this name for existing consumers. Declaring the
+ * shape locally let it drift from the type both execution paths resolve against.
+ */
+type UserData = UserContext$1;
+/**
+ * User context value.
+ */
+interface UserContextValue {
+    /** Current user data (null if not logged in) */
+    user: UserData | null;
+    /** Check if user is logged in */
+    isLoggedIn: boolean;
+    /** Check if user has a specific role */
+    hasRole: (role: string) => boolean;
+    /** Check if user has a specific permission */
+    hasPermission: (permission: string) => boolean;
+    /** Check if user has any of the specified roles */
+    hasAnyRole: (roles: string[]) => boolean;
+    /** Check if user has all of the specified permissions */
+    hasAllPermissions: (permissions: string[]) => boolean;
+    /** Get a user field by path (for @user.field bindings) */
+    getUserField: (path: string) => FieldValue | undefined;
+}
+declare const UserContext: React__default.Context<UserContextValue | null>;
+interface UserProviderProps {
+    /** User data (null if not logged in) */
+    user?: UserData | null;
+    /** Children to render */
+    children: React__default.ReactNode;
+}
+/**
+ * Provider component that provides user context to the application.
+ *
+ * Provides RBAC helpers and field access for @user bindings.
+ */
+declare function UserProvider({ user, children, }: UserProviderProps): React__default.ReactElement;
+/**
+ * Hook to access the user context.
+ *
+ * Returns default values if used outside of UserProvider (for resilience).
+ *
+ * @example
+ * ```tsx
+ * function AdminPanel() {
+ *   const { user, hasRole, hasPermission } = useUser();
+ *
+ *   if (!hasRole('admin') && !hasPermission('admin:access')) {
+ *     return <AccessDenied />;
+ *   }
+ *
+ *   return <div>Welcome, {user?.name}</div>;
+ * }
+ * ```
+ */
+declare function useUser(): UserContextValue;
+/**
+ * Hook to check if user has a specific role.
+ * Convenience wrapper around useUser().hasRole().
+ */
+declare function useHasRole(role: string): boolean;
+/**
+ * Hook to check if user has a specific permission.
+ * Convenience wrapper around useUser().hasPermission().
+ */
+declare function useHasPermission(permission: string): boolean;
+/**
+ * Hook to get user data for @user bindings in S-expressions.
+ * Returns the user data object compatible with EvaluationContext.user
+ */
+declare function useUserForEvaluation(): UserData | undefined;
+
+/**
+ * Arbitrary-value Tailwind classes (`w-[243px]`) in a schema exist only as
+ * data, so build-time Tailwind never compiled them. A host that renders
+ * schemas at runtime provides a compiler (e.g. the builder's server running
+ * Tailwind with this package's preset — `@almadar/ui/tailwind-compile`);
+ * `useArbitraryClassStyles(schema)` compiles each class once and appends its
+ * CSS to one shared `<style>`. Without a provider it does nothing.
+ */
+
+declare const ARBITRARY_CLASS_STYLE_ID = "almadar-arbitrary-classes";
+/** Compiles Tailwind classes to CSS. */
+type ArbitraryClassCompiler = (classes: string[]) => Promise<string>;
+interface ArbitraryClassCompilerProviderProps {
+    compile: ArbitraryClassCompiler;
+    children: React__default.ReactNode;
+}
+declare function ArbitraryClassCompilerProvider({ compile, children }: ArbitraryClassCompilerProviderProps): React__default.ReactElement;
+/** Forget what was compiled and drop the stylesheet (tests; a fresh document). */
+declare function resetArbitraryClassStyles(): void;
+declare function useArbitraryClassStyles(schema: OrbitalSchema | null | undefined): void;
+
+export { ARBITRARY_CLASS_STYLE_ID as A, CurrentPagePathContext as C, DesignThemeProvider as D, OrbitalThemeProvider as O, UserContext as U, ArbitraryClassCompilerProvider as b, CurrentPagePathProvider as d, UserProvider as i, useCurrentPagePath as k, useDesignTheme as l, useHasPermission as m, useHasRole as n, useUser as o, useUserForEvaluation as p, resetArbitraryClassStyles as r, useArbitraryClassStyles as u };
+export type { ArbitraryClassCompiler as a, ArbitraryClassCompilerProviderProps as c, CurrentPagePathProviderProps as e, OrbitalThemeProviderProps as f, UserContextValue as g, UserData as h, UserProviderProps as j };

package/dist/AvlGlyph-EPJKFEO3.js

@@ -0,0 +1,6 @@
+export { AVL_GLYPH_KINDS, AvlGlyph } from './chunk-CPLN6NBQ.js';
+import './chunk-HH5KSMH5.js';
+import './chunk-DZBQA2OW.js';
+import './chunk-UXLE3IPR.js';
+import './chunk-4YXBKHHM.js';
+import './chunk-G7DCAZ22.js';

package/dist/AvlStateMachine-RKZIKNGC.js

@@ -0,0 +1,9 @@
+export { AvlStateMachine, BODY_CHAR, MARGIN, MAX_SCALE, MIN_SCALE, MONO_CHAR, PILL_H, metricsFor, pillWidth } from './chunk-SP5CDJ6K.js';
+import './chunk-TXAUOLWZ.js';
+import './chunk-AB3X7QTE.js';
+import './chunk-DZBQA2OW.js';
+import './chunk-TZZBINQY.js';
+import './chunk-PCR37T3U.js';
+import './chunk-UXLE3IPR.js';
+import './chunk-4YXBKHHM.js';
+import './chunk-G7DCAZ22.js';

package/dist/AvlTransitionDetail-63SD6GZF.js

@@ -0,0 +1,11 @@
+export { AvlTransitionDetail } from './chunk-K4MOPSEL.js';
+import './chunk-ILQXJ2AR.js';
+import './chunk-REXYVBUO.js';
+import './chunk-AGXD77SL.js';
+import './chunk-TXAUOLWZ.js';
+import './chunk-AB3X7QTE.js';
+import './chunk-DZBQA2OW.js';
+import './chunk-PCR37T3U.js';
+import './chunk-UXLE3IPR.js';
+import './chunk-4YXBKHHM.js';
+import './chunk-G7DCAZ22.js';

package/dist/AvlTransitionExplainer-ZBTLOM3T.js

@@ -0,0 +1,12 @@
+export { AvlTransitionExplainer } from './chunk-X3DMMX27.js';
+import './chunk-K4MOPSEL.js';
+import './chunk-ILQXJ2AR.js';
+import './chunk-REXYVBUO.js';
+import './chunk-AGXD77SL.js';
+import './chunk-TXAUOLWZ.js';
+import './chunk-AB3X7QTE.js';
+import './chunk-DZBQA2OW.js';
+import './chunk-PCR37T3U.js';
+import './chunk-UXLE3IPR.js';
+import './chunk-4YXBKHHM.js';
+import './chunk-G7DCAZ22.js';

package/dist/BehaviorView-YS5G4GNB.js

@@ -0,0 +1,11 @@
+export { BehaviorView } from './chunk-ROICKAU7.js';
+import './chunk-SP5CDJ6K.js';
+import './chunk-AGXD77SL.js';
+import './chunk-TXAUOLWZ.js';
+import './chunk-AB3X7QTE.js';
+import './chunk-DZBQA2OW.js';
+import './chunk-TZZBINQY.js';
+import './chunk-PCR37T3U.js';
+import './chunk-UXLE3IPR.js';
+import './chunk-4YXBKHHM.js';
+import './chunk-G7DCAZ22.js';