aeon-ui-engine 1.0.1 → 1.0.3

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

@@ -0,0 +1,41 @@
+// src/machines/tabs.ts
+import { assign, setup } from "xstate";
+var tabsMachine = setup({
+  types: {
+    context: {},
+    events: {},
+    input: {}
+  },
+  guards: {
+    notDisabled: ({ context }) => !context.disabled,
+    hasValue: ({ event }) => event.type === "SELECT" && Boolean(event.value)
+  },
+  actions: {
+    select: assign({
+      value: ({ event }) => event.type === "SELECT" ? event.value : ""
+    }),
+    setValue: assign({
+      value: ({ event }) => event.type === "SET_VALUE" ? event.value : ""
+    })
+  }
+}).createMachine({
+  id: "tabs",
+  context: ({ input }) => ({
+    value: input.value ?? "",
+    disabled: input.disabled ?? false
+  }),
+  /** Single stable region: which trigger is active. */
+  initial: "active",
+  states: {
+    active: {
+      on: {
+        SELECT: { actions: "select", guard: "hasValue" },
+        SET_VALUE: { actions: "setValue" }
+      }
+    }
+  }
+});
+
+export {
+  tabsMachine
+};

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

@@ -0,0 +1,90 @@
+// src/machines/async.ts
+import { assign, setup } from "xstate";
+var ASYNC_LIFECYCLE_STATES = [
+  "idle",
+  "loading",
+  "success",
+  "failure",
+  "empty"
+];
+function isEmptyAsyncData(data) {
+  if (data == null) return true;
+  if (typeof data === "string") return data.length === 0;
+  if (Array.isArray(data)) return data.length === 0;
+  return false;
+}
+function createAsyncMachine() {
+  return setup({
+    types: {
+      context: {},
+      events: {}
+    },
+    actions: {
+      clear: assign({ data: null, error: null }),
+      resolve: assign({
+        data: ({ event }) => event.type === "RESOLVE" ? event.data : null,
+        error: null,
+        stale: false
+      }),
+      markStale: assign({ stale: true }),
+      clearStale: assign({ stale: false }),
+      reject: assign({
+        error: ({ event }) => event.type === "REJECT" ? event.error : null,
+        data: null
+      })
+    }
+  }).createMachine({
+    id: "async",
+    context: { data: null, error: null },
+    initial: "idle",
+    states: {
+      idle: {
+        on: {
+          FETCH: "loading",
+          RESET: { actions: "clear" }
+        }
+      },
+      loading: {
+        on: {
+          RESOLVE: [
+            {
+              target: "empty",
+              actions: "resolve",
+              guard: ({ event }) => event.type === "RESOLVE" && isEmptyAsyncData(event.data)
+            },
+            { target: "success", actions: "resolve" }
+          ],
+          REJECT: { target: "failure", actions: "reject" }
+        }
+      },
+      empty: {
+        on: {
+          FETCH: "loading",
+          RESET: { target: "idle", actions: "clear" }
+        }
+      },
+      success: {
+        on: {
+          FETCH: { target: "loading", actions: "clearStale" },
+          STALE: { actions: "markStale" },
+          REFRESH: { actions: "clearStale" },
+          RESET: { target: "idle", actions: "clear" }
+        }
+      },
+      failure: {
+        on: {
+          FETCH: "loading",
+          RESET: { target: "idle", actions: "clear" }
+        }
+      }
+    }
+  });
+}
+var asyncMachine = createAsyncMachine();
+
+export {
+  ASYNC_LIFECYCLE_STATES,
+  isEmptyAsyncData,
+  createAsyncMachine,
+  asyncMachine
+};

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

@@ -0,0 +1,46 @@
+// src/machines/accordion.ts
+import { assign, setup } from "xstate";
+function toggleItem(items, item, multiple, collapsible) {
+  const isOpen = items.includes(item);
+  if (!multiple) {
+    if (isOpen) return collapsible ? [] : items;
+    return [item];
+  }
+  if (isOpen) return items.filter((i) => i !== item);
+  return [...items, item];
+}
+var accordionMachine = setup({
+  types: {
+    context: {},
+    events: {},
+    input: {}
+  },
+  actions: {
+    toggle: assign({
+      value: ({ context, event }) => event.type === "TOGGLE" ? toggleItem(context.value, event.item, context.multiple, context.collapsible) : context.value
+    }),
+    setValue: assign({
+      value: ({ event }) => event.type === "SET_VALUE" ? event.value : []
+    })
+  }
+}).createMachine({
+  id: "accordion",
+  context: ({ input }) => ({
+    value: input.value ?? [],
+    multiple: input.multiple ?? false,
+    collapsible: input.collapsible ?? true
+  }),
+  initial: "managing",
+  states: {
+    managing: {
+      on: {
+        TOGGLE: { actions: "toggle" },
+        SET_VALUE: { actions: "setValue" }
+      }
+    }
+  }
+});
+
+export {
+  accordionMachine
+};

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

@@ -0,0 +1,43 @@
+// src/machines/popover.ts
+import { assign, setup } from "xstate";
+var popoverMachine = setup({
+  types: {
+    context: {},
+    events: {},
+    input: {}
+  },
+  actions: {
+    markOpen: assign({ open: true }),
+    markClosed: assign({ open: false }),
+    toggleOpen: assign({ open: ({ context }) => !context.open }),
+    setOpen: assign({
+      open: ({ event }) => event.type === "SET_OPEN" ? event.open : false
+    })
+  }
+}).createMachine({
+  id: "popover",
+  context: ({ input }) => ({ open: input.open ?? false }),
+  initial: "closed",
+  states: {
+    closed: {
+      on: {
+        OPEN: { target: "open", actions: "markOpen" },
+        TOGGLE: { target: "open", actions: "markOpen" },
+        SET_OPEN: [{ target: "open", actions: "markOpen", guard: ({ event }) => event.open }]
+      }
+    },
+    open: {
+      on: {
+        CLOSE: { target: "closed", actions: "markClosed" },
+        ESCAPE: { target: "closed", actions: "markClosed" },
+        POINTER_DOWN_OUTSIDE: { target: "closed", actions: "markClosed" },
+        TOGGLE: { target: "closed", actions: "markClosed" },
+        SET_OPEN: [{ target: "closed", actions: "markClosed", guard: ({ event }) => !event.open }]
+      }
+    }
+  }
+});
+
+export {
+  popoverMachine
+};

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

@@ -0,0 +1,72 @@
+// src/machines/slider.ts
+import { assign, setup } from "xstate";
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function snap(value, min, max, step) {
+  if (step <= 0) return clamp(value, min, max);
+  const snapped = min + Math.round((value - min) / step) * step;
+  return clamp(snapped, min, max);
+}
+var sliderMachine = setup({
+  types: {
+    context: {},
+    events: {},
+    input: {}
+  },
+  guards: {
+    notDisabled: ({ context }) => !context.disabled
+  },
+  actions: {
+    setValue: assign({
+      value: ({ context, event }) => event.type === "SET_VALUE" ? snap(event.value, context.min, context.max, context.step) : context.value
+    }),
+    step: assign({
+      value: ({ context, event }) => event.type === "STEP" ? snap(context.value + event.delta, context.min, context.max, context.step) : context.value
+    }),
+    home: assign({
+      value: ({ context }) => context.min
+    }),
+    end: assign({
+      value: ({ context }) => context.max
+    })
+  }
+}).createMachine({
+  id: "slider",
+  context: ({ input }) => ({
+    value: snap(input.value ?? input.min, input.min, input.max, input.step),
+    min: input.min,
+    max: input.max,
+    step: input.step,
+    disabled: input.disabled ?? false
+  }),
+  initial: "interaction",
+  states: {
+    interaction: {
+      initial: "idle",
+      states: {
+        idle: {
+          on: {
+            SET_VALUE: { actions: "setValue", guard: "notDisabled" },
+            STEP: { actions: "step", guard: "notDisabled" },
+            HOME: { actions: "home", guard: "notDisabled" },
+            END: { actions: "end", guard: "notDisabled" },
+            POINTER_DOWN: { target: "dragging", guard: "notDisabled" }
+          }
+        },
+        dragging: {
+          on: {
+            SET_VALUE: { actions: "setValue" },
+            POINTER_UP: "idle"
+          }
+        }
+      }
+    }
+  }
+});
+
+export {
+  clamp,
+  snap,
+  sliderMachine
+};

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

@@ -0,0 +1,49 @@
+// src/machines/dialog.ts
+import { assign, setup } from "xstate";
+var dialogMachine = setup({
+  types: {
+    context: {},
+    events: {},
+    input: {}
+  },
+  actions: {
+    markOpen: assign({ open: true }),
+    markClosed: assign({ open: false }),
+    toggleOpen: assign({ open: ({ context }) => !context.open }),
+    setOpen: assign({
+      open: ({ event }) => event.type === "SET_OPEN" ? event.open : false
+    })
+  }
+}).createMachine({
+  id: "dialog",
+  context: ({ input }) => ({
+    open: input.open ?? false
+  }),
+  initial: "closed",
+  states: {
+    closed: {
+      on: {
+        OPEN: { target: "open", actions: "markOpen" },
+        TOGGLE: { target: "open", actions: "markOpen" },
+        SET_OPEN: [
+          { target: "open", actions: "markOpen", guard: ({ event }) => event.open }
+        ]
+      }
+    },
+    open: {
+      on: {
+        CLOSE: { target: "closed", actions: "markClosed" },
+        ESCAPE: { target: "closed", actions: "markClosed" },
+        POINTER_DOWN_OUTSIDE: { target: "closed", actions: "markClosed" },
+        TOGGLE: { target: "closed", actions: "markClosed" },
+        SET_OPEN: [
+          { target: "closed", actions: "markClosed", guard: ({ event }) => !event.open }
+        ]
+      }
+    }
+  }
+});
+
+export {
+  dialogMachine
+};

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

@@ -0,0 +1,56 @@
+// src/machines/button.ts
+import { setup } from "xstate";
+var BUTTON_LIFECYCLE_STATES = [
+  "idle",
+  "pending",
+  "success",
+  "failure",
+  "disabled"
+];
+var buttonLifecycleMachine = setup({
+  types: {
+    events: {}
+  }
+}).createMachine({
+  id: "buttonLifecycle",
+  initial: "idle",
+  states: {
+    idle: {
+      on: {
+        PRESS: "pending",
+        DISABLE: "disabled"
+      }
+    },
+    pending: {
+      on: {
+        SUCCEED: "success",
+        FAIL: "failure",
+        DISABLE: "disabled"
+      }
+    },
+    success: {
+      on: {
+        RESET: "idle",
+        PRESS: "pending",
+        DISABLE: "disabled"
+      }
+    },
+    failure: {
+      on: {
+        RESET: "idle",
+        PRESS: "pending",
+        DISABLE: "disabled"
+      }
+    },
+    disabled: {
+      on: {
+        ENABLE: "idle"
+      }
+    }
+  }
+});
+
+export {
+  BUTTON_LIFECYCLE_STATES,
+  buttonLifecycleMachine
+};

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,11 @@
+export { ToggleContext, ToggleEvent, toggleMachine } from './machines/toggle.js';
+export { DialogContext, DialogEvent, dialogMachine } from './machines/dialog.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';
+import 'xstate';

package/packages/primitives/dist/index.js

@@ -0,0 +1,60 @@
+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 {
+  ASYNC_LIFECYCLE_STATES,
+  asyncMachine,
+  createAsyncMachine,
+  isEmptyAsyncData
+} from "./chunk-J6JHKMVM.js";
+import {
+  BUTTON_LIFECYCLE_STATES,
+  buttonLifecycleMachine
+} from "./chunk-WVICCOQH.js";
+import {
+  dialogMachine
+} from "./chunk-SZV6KGXN.js";
+import {
+  FIELD_INTERACTION_STATES,
+  FIELD_SUBMISSION_STATES,
+  FIELD_VALIDATION_STATES,
+  fieldMachine
+} from "./chunk-ZMGRX64G.js";
+import {
+  popoverMachine
+} from "./chunk-LVNCD5F2.js";
+import {
+  clamp,
+  sliderMachine,
+  snap
+} from "./chunk-PB3LFHXU.js";
+export {
+  ASYNC_LIFECYCLE_STATES,
+  BUTTON_LIFECYCLE_STATES,
+  FIELD_INTERACTION_STATES,
+  FIELD_SUBMISSION_STATES,
+  FIELD_VALIDATION_STATES,
+  accordionMachine,
+  asyncMachine,
+  buttonLifecycleMachine,
+  clamp as clampSliderValue,
+  createAsyncMachine,
+  dialogMachine,
+  fieldMachine,
+  isEmptyAsyncData,
+  popoverMachine,
+  sliderMachine,
+  snap as snapSliderValue,
+  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/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: "clear";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "resolve";
+    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: "clear";
+    params: xstate.NonReducibleUnknown;
+} | {
+    type: "resolve";
+    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 };