aeon-ui-engine 1.0.2 → 1.1.0

package/packages/primitives/dist/chunk-YBPNI2LI.js

@@ -0,0 +1,70 @@
+// src/machines/sticky-bar.ts
+import { assign, setup } from "xstate";
+var STICKY_BAR_STATES = ["floating", "docked", "collapsed", "hidden"];
+var stickyBarMachine = setup({
+  types: {
+    context: {},
+    events: {},
+    input: {}
+  },
+  actions: {
+    setOffset: assign({
+      offsetPx: ({ event }) => event.type === "SET_OFFSET" ? event.offsetPx : 0
+    })
+  }
+}).createMachine({
+  id: "stickyBar",
+  context: ({ input }) => ({
+    offsetPx: input?.offsetPx ?? 0,
+    initial: input?.initial ?? "floating"
+  }),
+  initial: "resolve",
+  states: {
+    resolve: {
+      always: [
+        { target: "docked", guard: ({ context }) => context.initial === "docked" },
+        { target: "collapsed", guard: ({ context }) => context.initial === "collapsed" },
+        { target: "hidden", guard: ({ context }) => context.initial === "hidden" },
+        { target: "floating" }
+      ]
+    },
+    floating: {
+      on: {
+        DOCK: "docked",
+        COLLAPSE: "collapsed",
+        HIDE: "hidden",
+        SET_OFFSET: { actions: "setOffset" }
+      }
+    },
+    docked: {
+      on: {
+        FLOAT: "floating",
+        COLLAPSE: "collapsed",
+        HIDE: "hidden",
+        SET_OFFSET: { actions: "setOffset" }
+      }
+    },
+    collapsed: {
+      on: {
+        EXPAND: "floating",
+        DOCK: "docked",
+        FLOAT: "floating",
+        HIDE: "hidden",
+        SET_OFFSET: { actions: "setOffset" }
+      }
+    },
+    hidden: {
+      on: {
+        SHOW: "floating",
+        DOCK: "docked",
+        FLOAT: "floating",
+        SET_OFFSET: { actions: "setOffset" }
+      }
+    }
+  }
+});
+
+export {
+  STICKY_BAR_STATES,
+  stickyBarMachine
+};

package/packages/primitives/dist/chunk-ZMGRX64G.js

@@ -0,0 +1,74 @@
+// src/machines/field.ts
+import { setup } from "xstate";
+var FIELD_INTERACTION_STATES = ["pristine", "dirty"];
+var FIELD_VALIDATION_STATES = ["valid", "invalid"];
+var FIELD_SUBMISSION_STATES = ["idle", "pending"];
+var fieldMachine = setup({
+  types: {
+    events: {}
+  }
+}).createMachine({
+  id: "field",
+  type: "parallel",
+  states: {
+    interaction: {
+      initial: "pristine",
+      states: {
+        pristine: {
+          on: {
+            INPUT: "dirty",
+            BLUR: "dirty"
+          }
+        },
+        dirty: {
+          on: {
+            RESET: "pristine"
+          }
+        }
+      }
+    },
+    validation: {
+      initial: "valid",
+      states: {
+        valid: {
+          on: {
+            VALIDATE: [
+              { target: "invalid", guard: ({ event }) => event.type === "VALIDATE" && !event.valid }
+            ]
+          }
+        },
+        invalid: {
+          on: {
+            VALIDATE: [
+              { target: "valid", guard: ({ event }) => event.type === "VALIDATE" && event.valid }
+            ],
+            RESET: "valid"
+          }
+        }
+      }
+    },
+    submission: {
+      initial: "idle",
+      states: {
+        idle: {
+          on: {
+            SUBMIT: "pending"
+          }
+        },
+        pending: {
+          on: {
+            SUBMIT_DONE: "idle",
+            SUBMIT_FAIL: "idle"
+          }
+        }
+      }
+    }
+  }
+});
+
+export {
+  FIELD_INTERACTION_STATES,
+  FIELD_VALIDATION_STATES,
+  FIELD_SUBMISSION_STATES,
+  fieldMachine
+};

package/packages/primitives/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { ToggleContext, ToggleEvent, toggleMachine } from './machines/toggle.js';
+export { DialogContext, DialogEvent, dialogMachine } from './machines/dialog.js';
+export { PanelContext, PanelEvent, panelMachine } from './machines/panel.js';
+export { TabsContext, TabsEvent, tabsMachine } from './machines/tabs.js';
+export { AccordionContext, AccordionEvent, accordionMachine } from './machines/accordion.js';
+export { ASYNC_LIFECYCLE_STATES, AsyncContext, AsyncEvent, AsyncLifecycleState, asyncMachine, createAsyncMachine, isEmptyAsyncData } from './machines/async.js';
+export { BUTTON_LIFECYCLE_STATES, ButtonLifecycleEvent, ButtonLifecycleState, buttonLifecycleMachine } from './machines/button.js';
+export { FIELD_INTERACTION_STATES, FIELD_SUBMISSION_STATES, FIELD_VALIDATION_STATES, FieldEvent, FieldInteractionState, FieldSubmissionState, FieldValidationState, fieldMachine } from './machines/field.js';
+export { PopoverContext, PopoverEvent, popoverMachine } from './machines/popover.js';
+export { ToastContext, ToastEvent, toastMachine } from './machines/toast.js';
+export { SliderContext, SliderEvent, clampSliderValue, sliderMachine, snapSliderValue } from './machines/slider.js';
+export { APP_SHELL_STATES, AppShellContext, AppShellEvent, AppShellState, appShellMachine } from './machines/app-shell.js';
+export { STICKY_BAR_STATES, StickyBarContext, StickyBarEvent, StickyBarState, stickyBarMachine } from './machines/sticky-bar.js';
+export { CONTENT_REGION_STATES, ContentRegionContext, ContentRegionEvent, ContentRegionState, contentRegionMachine } from './machines/content-region.js';
+import 'xstate';

package/packages/primitives/dist/index.js

@@ -0,0 +1,82 @@
+import {
+  panelMachine
+} from "./chunk-V5D7LS4J.js";
+import {
+  popoverMachine
+} from "./chunk-LVNCD5F2.js";
+import {
+  clamp,
+  sliderMachine,
+  snap
+} from "./chunk-PB3LFHXU.js";
+import {
+  STICKY_BAR_STATES,
+  stickyBarMachine
+} from "./chunk-YBPNI2LI.js";
+import {
+  tabsMachine
+} from "./chunk-HONROWUG.js";
+import {
+  toastMachine
+} from "./chunk-5S4DIRL4.js";
+import {
+  toggleMachine
+} from "./chunk-H4KOEPYC.js";
+import {
+  accordionMachine
+} from "./chunk-JBAG5E6W.js";
+import {
+  APP_SHELL_STATES,
+  appShellMachine
+} from "./chunk-R25CUHNF.js";
+import {
+  ASYNC_LIFECYCLE_STATES,
+  asyncMachine,
+  createAsyncMachine,
+  isEmptyAsyncData
+} from "./chunk-J6JHKMVM.js";
+import {
+  BUTTON_LIFECYCLE_STATES,
+  buttonLifecycleMachine
+} from "./chunk-WVICCOQH.js";
+import {
+  CONTENT_REGION_STATES,
+  contentRegionMachine
+} from "./chunk-RO2DMFN5.js";
+import {
+  dialogMachine
+} from "./chunk-SZV6KGXN.js";
+import {
+  FIELD_INTERACTION_STATES,
+  FIELD_SUBMISSION_STATES,
+  FIELD_VALIDATION_STATES,
+  fieldMachine
+} from "./chunk-ZMGRX64G.js";
+export {
+  APP_SHELL_STATES,
+  ASYNC_LIFECYCLE_STATES,
+  BUTTON_LIFECYCLE_STATES,
+  CONTENT_REGION_STATES,
+  FIELD_INTERACTION_STATES,
+  FIELD_SUBMISSION_STATES,
+  FIELD_VALIDATION_STATES,
+  STICKY_BAR_STATES,
+  accordionMachine,
+  appShellMachine,
+  asyncMachine,
+  buttonLifecycleMachine,
+  clamp as clampSliderValue,
+  contentRegionMachine,
+  createAsyncMachine,
+  dialogMachine,
+  fieldMachine,
+  isEmptyAsyncData,
+  panelMachine,
+  popoverMachine,
+  sliderMachine,
+  snap as snapSliderValue,
+  stickyBarMachine,
+  tabsMachine,
+  toastMachine,
+  toggleMachine
+};

package/packages/primitives/dist/machines/accordion.d.ts

@@ -0,0 +1,34 @@
+import * as xstate from 'xstate';
+
+interface AccordionContext {
+    value: string[];
+    multiple: boolean;
+    collapsible: boolean;
+}
+type AccordionEvent = {
+    type: 'TOGGLE';
+    item: string;
+} | {
+    type: 'SET_VALUE';
+    value: string[];
+};
+declare const accordionMachine: xstate.StateMachine<AccordionContext, {
+    type: "TOGGLE";
+    item: string;
+} | {
+    type: "SET_VALUE";
+    value: string[];
+}, {}, never, {
+    type: "toggle";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "setValue";
+    params: xstate.NonReducibleUnknown;
+}, never, never, "managing", string, AccordionContext, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+    id: "accordion";
+    states: {
+        readonly managing: {};
+    };
+}>;
+
+export { type AccordionContext, type AccordionEvent, accordionMachine };

package/packages/primitives/dist/machines/accordion.js

@@ -0,0 +1,6 @@
+import {
+  accordionMachine
+} from "../chunk-JBAG5E6W.js";
+export {
+  accordionMachine
+};

package/packages/primitives/dist/machines/app-shell.d.ts

@@ -0,0 +1,57 @@
+import * as xstate from 'xstate';
+
+declare const APP_SHELL_STATES: readonly ["idle", "overlayOpen"];
+type AppShellState = (typeof APP_SHELL_STATES)[number];
+interface AppShellContext {
+    /** Bottom (or edge) dock chrome — tab bar, action dock. */
+    dockVisible: boolean;
+}
+type AppShellEvent = {
+    type: 'OPEN_OVERLAY';
+} | {
+    type: 'CLOSE_OVERLAY';
+} | {
+    type: 'SHOW_DOCK';
+} | {
+    type: 'HIDE_DOCK';
+} | {
+    type: 'SET_DOCK';
+    visible: boolean;
+};
+/**
+ * Application chrome frame — layered top / content / dock / overlays.
+ * Reference: HandCash items-market MainLayout (content dims when overlay open).
+ *
+ * Parallel concerns:
+ * - region `chrome`: idle | overlayOpen (content inert + scrim)
+ * - context `dockVisible`: whether the edge dock is shown
+ */
+declare const appShellMachine: xstate.StateMachine<AppShellContext, {
+    type: "OPEN_OVERLAY";
+} | {
+    type: "CLOSE_OVERLAY";
+} | {
+    type: "SHOW_DOCK";
+} | {
+    type: "HIDE_DOCK";
+} | {
+    type: "SET_DOCK";
+    visible: boolean;
+}, {}, never, {
+    type: "showDock";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "hideDock";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "setDock";
+    params: xstate.NonReducibleUnknown;
+}, never, never, "idle" | "overlayOpen", string, Partial<AppShellContext>, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+    id: "appShell";
+    states: {
+        readonly idle: {};
+        readonly overlayOpen: {};
+    };
+}>;
+
+export { APP_SHELL_STATES, type AppShellContext, type AppShellEvent, type AppShellState, appShellMachine };

package/packages/primitives/dist/machines/app-shell.js

@@ -0,0 +1,8 @@
+import {
+  APP_SHELL_STATES,
+  appShellMachine
+} from "../chunk-R25CUHNF.js";
+export {
+  APP_SHELL_STATES,
+  appShellMachine
+};

package/packages/primitives/dist/machines/async.d.ts

@@ -0,0 +1,111 @@
+import * as xstate from 'xstate';
+
+/** Stable lifecycle states for async data regions (see STATES.md). */
+declare const ASYNC_LIFECYCLE_STATES: readonly ["idle", "loading", "success", "failure", "empty"];
+type AsyncLifecycleState = (typeof ASYNC_LIFECYCLE_STATES)[number];
+declare function isEmptyAsyncData(data: unknown): boolean;
+/**
+ * Thesis §2.1: fetch lifecycle as sequential, well-defined states.
+ * This machine models fetch lifecycle as mutually exclusive states.
+ */
+interface AsyncContext<T = unknown> {
+    data: T | null;
+    error: string | null;
+    /** Success with background refresh — style readout as `success stale` (see STATES.md). */
+    stale?: boolean;
+}
+type AsyncEvent<T = unknown> = {
+    type: 'FETCH';
+} | {
+    type: 'RESOLVE';
+    data: T;
+} | {
+    type: 'REJECT';
+    error: string;
+} | {
+    type: 'RESET';
+} | {
+    type: 'STALE';
+} | {
+    type: 'REFRESH';
+};
+declare function createAsyncMachine<T = unknown>(): xstate.StateMachine<AsyncContext<T>, {
+    type: "FETCH";
+} | {
+    type: "REJECT";
+    error: string;
+} | {
+    type: "RESET";
+} | {
+    type: "STALE";
+} | {
+    type: "REFRESH";
+} | {
+    type: "RESOLVE";
+    data: T;
+}, {}, never, {
+    type: "resolve";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "clear";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "markStale";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "clearStale";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "reject";
+    params: xstate.NonReducibleUnknown;
+}, never, never, "idle" | "loading" | "success" | "failure" | "empty", string, xstate.NonReducibleUnknown, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+    id: "async";
+    states: {
+        readonly idle: {};
+        readonly loading: {};
+        readonly empty: {};
+        readonly success: {};
+        readonly failure: {};
+    };
+}>;
+declare const asyncMachine: xstate.StateMachine<AsyncContext<unknown>, {
+    type: "FETCH";
+} | {
+    type: "REJECT";
+    error: string;
+} | {
+    type: "RESET";
+} | {
+    type: "STALE";
+} | {
+    type: "REFRESH";
+} | {
+    type: "RESOLVE";
+    data: unknown;
+}, {}, never, {
+    type: "resolve";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "clear";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "markStale";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "clearStale";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "reject";
+    params: xstate.NonReducibleUnknown;
+}, never, never, "idle" | "loading" | "success" | "failure" | "empty", string, xstate.NonReducibleUnknown, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+    id: "async";
+    states: {
+        readonly idle: {};
+        readonly loading: {};
+        readonly empty: {};
+        readonly success: {};
+        readonly failure: {};
+    };
+}>;
+
+export { ASYNC_LIFECYCLE_STATES, type AsyncContext, type AsyncEvent, type AsyncLifecycleState, asyncMachine, createAsyncMachine, isEmptyAsyncData };

package/packages/primitives/dist/machines/async.js

@@ -0,0 +1,12 @@
+import {
+  ASYNC_LIFECYCLE_STATES,
+  asyncMachine,
+  createAsyncMachine,
+  isEmptyAsyncData
+} from "../chunk-J6JHKMVM.js";
+export {
+  ASYNC_LIFECYCLE_STATES,
+  asyncMachine,
+  createAsyncMachine,
+  isEmptyAsyncData
+};

package/packages/primitives/dist/machines/button.d.ts

@@ -0,0 +1,45 @@
+import * as xstate from 'xstate';
+
+declare const BUTTON_LIFECYCLE_STATES: readonly ["idle", "pending", "success", "failure", "disabled"];
+type ButtonLifecycleState = (typeof BUTTON_LIFECYCLE_STATES)[number];
+type ButtonLifecycleEvent = {
+    type: 'PRESS';
+} | {
+    type: 'SUCCEED';
+} | {
+    type: 'FAIL';
+} | {
+    type: 'RESET';
+} | {
+    type: 'DISABLE';
+} | {
+    type: 'ENABLE';
+};
+/**
+ * Submit / action button lifecycle — idle → pending → success | failure.
+ * Use for controls that represent an in-flight operation, not mere `disabled`.
+ */
+declare const buttonLifecycleMachine: xstate.StateMachine<xstate.MachineContext, {
+    type: "PRESS";
+} | {
+    type: "SUCCEED";
+} | {
+    type: "FAIL";
+} | {
+    type: "RESET";
+} | {
+    type: "DISABLE";
+} | {
+    type: "ENABLE";
+}, {}, never, never, never, never, "disabled" | "idle" | "success" | "failure" | "pending", string, xstate.NonReducibleUnknown, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+    id: "buttonLifecycle";
+    states: {
+        readonly idle: {};
+        readonly pending: {};
+        readonly success: {};
+        readonly failure: {};
+        readonly disabled: {};
+    };
+}>;
+
+export { BUTTON_LIFECYCLE_STATES, type ButtonLifecycleEvent, type ButtonLifecycleState, buttonLifecycleMachine };

package/packages/primitives/dist/machines/button.js

@@ -0,0 +1,8 @@
+import {
+  BUTTON_LIFECYCLE_STATES,
+  buttonLifecycleMachine
+} from "../chunk-WVICCOQH.js";
+export {
+  BUTTON_LIFECYCLE_STATES,
+  buttonLifecycleMachine
+};

package/packages/primitives/dist/machines/content-region.d.ts

@@ -0,0 +1,72 @@
+import * as xstate from 'xstate';
+
+/** Totality for page / list / hub bodies — every state has a slot. */
+declare const CONTENT_REGION_STATES: readonly ["idle", "pending", "empty", "error", "ready", "loadingMore", "success"];
+type ContentRegionState = (typeof CONTENT_REGION_STATES)[number];
+interface ContentRegionContext {
+    error: string | null;
+}
+type ContentRegionEvent = {
+    type: 'LOAD';
+} | {
+    type: 'RESOLVE';
+    empty?: boolean;
+} | {
+    type: 'REJECT';
+    error: string;
+} | {
+    type: 'RETRY';
+} | {
+    type: 'LOAD_MORE';
+} | {
+    type: 'MORE_DONE';
+    empty?: boolean;
+} | {
+    type: 'SUCCEED';
+} | {
+    type: 'RESET';
+};
+/**
+ * Content region — status-slotted body under app chrome.
+ * Makes async / list / hub totality trivial: pending | empty | error | ready | loadingMore | success.
+ * Reference: items-market EmptyPlaceholder + loading skeletons + InfiniteScrollSentinel.
+ */
+declare const contentRegionMachine: xstate.StateMachine<ContentRegionContext, {
+    type: "LOAD";
+} | {
+    type: "RESOLVE";
+    empty?: boolean;
+} | {
+    type: "REJECT";
+    error: string;
+} | {
+    type: "RETRY";
+} | {
+    type: "LOAD_MORE";
+} | {
+    type: "MORE_DONE";
+    empty?: boolean;
+} | {
+    type: "SUCCEED";
+} | {
+    type: "RESET";
+}, {}, never, {
+    type: "clearError";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "setError";
+    params: xstate.NonReducibleUnknown;
+}, never, never, "error" | "idle" | "success" | "empty" | "pending" | "ready" | "loadingMore", string, Partial<ContentRegionContext>, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+    id: "contentRegion";
+    states: {
+        readonly idle: {};
+        readonly pending: {};
+        readonly empty: {};
+        readonly error: {};
+        readonly ready: {};
+        readonly loadingMore: {};
+        readonly success: {};
+    };
+}>;
+
+export { CONTENT_REGION_STATES, type ContentRegionContext, type ContentRegionEvent, type ContentRegionState, contentRegionMachine };

package/packages/primitives/dist/machines/content-region.js

@@ -0,0 +1,8 @@
+import {
+  CONTENT_REGION_STATES,
+  contentRegionMachine
+} from "../chunk-RO2DMFN5.js";
+export {
+  CONTENT_REGION_STATES,
+  contentRegionMachine
+};

package/packages/primitives/dist/machines/dialog.d.ts

@@ -0,0 +1,57 @@
+import * as xstate from 'xstate';
+
+interface DialogContext {
+    open: boolean;
+}
+type DialogEvent = {
+    type: 'OPEN';
+} | {
+    type: 'CLOSE';
+} | {
+    type: 'TOGGLE';
+} | {
+    type: 'SET_OPEN';
+    open: boolean;
+} | {
+    type: 'ESCAPE';
+} | {
+    type: 'POINTER_DOWN_OUTSIDE';
+};
+/**
+ * Dialog visibility is a single orthogonal region: closed | open.
+ * Open and closed are distinct, stable states.
+ */
+declare const dialogMachine: xstate.StateMachine<DialogContext, {
+    type: "OPEN";
+} | {
+    type: "CLOSE";
+} | {
+    type: "TOGGLE";
+} | {
+    type: "SET_OPEN";
+    open: boolean;
+} | {
+    type: "ESCAPE";
+} | {
+    type: "POINTER_DOWN_OUTSIDE";
+}, {}, never, {
+    type: "markOpen";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "markClosed";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "toggleOpen";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "setOpen";
+    params: xstate.NonReducibleUnknown;
+}, never, never, "open" | "closed", string, DialogContext, xstate.NonReducibleUnknown, xstate.EventObject, xstate.MetaObject, {
+    id: "dialog";
+    states: {
+        readonly closed: {};
+        readonly open: {};
+    };
+}>;
+
+export { type DialogContext, type DialogEvent, dialogMachine };

package/packages/primitives/dist/machines/dialog.js

@@ -0,0 +1,6 @@
+import {
+  dialogMachine
+} from "../chunk-SZV6KGXN.js";
+export {
+  dialogMachine
+};