@wow-two-beta/ui-vue 0.0.2

package/dist/chunks/RovingFocusGroup.vue_vue_type_script_setup_true_lang-DCpYSP2V.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RovingFocusGroup.vue_vue_type_script_setup_true_lang-DCpYSP2V.js","sources":["../../src/foundation/primitives/directionProvider/DirectionContext.ts","../../src/foundation/primitives/rovingFocusGroup/RovingFocusContext.ts","../../src/foundation/primitives/rovingFocusGroup/RovingFocusGroup.vue"],"sourcesContent":["import {\n  computed,\n  inject,\n  provide,\n  toValue,\n  type ComputedRef,\n  type InjectionKey,\n  type MaybeRefOrGetter,\n} from 'vue';\n\n/** Defines the reading direction of a subtree. */\nexport const Direction = {\n  /** Refers to left-to-right reading order. */\n  Ltr: 'ltr',\n  /** Refers to right-to-left reading order. */\n  Rtl: 'rtl',\n} as const;\n\nexport type Direction = (typeof Direction)[keyof typeof Direction];\n\n/**\n * React's `createContext(Direction.Ltr)` becomes an `InjectionKey` plus a\n * default at the injection site. The provided value is a `ComputedRef` rather\n * than a bare string so a `dir` change re-evaluates every consumer — Vue's\n * `provide` is not reactive on its own.\n */\nexport const DirectionKey: InjectionKey<ComputedRef<Direction>> = Symbol('wow-two.direction');\n\n/** The provider half — used by `DirectionProvider`, and by any component that owns a direction. */\nexport function provideDirection(dir: MaybeRefOrGetter<Direction>): ComputedRef<Direction> {\n  const direction = computed(() => toValue(dir));\n  provide(DirectionKey, direction);\n  return direction;\n}\n\n/**\n * Read the surrounding reading direction. Falls back to `ltr` outside any\n * provider, matching the React context's default value.\n */\nexport function useDirection(): ComputedRef<Direction> {\n  return inject(DirectionKey, () => computed<Direction>(() => Direction.Ltr), true);\n}\n","import {\n  computed,\n  inject,\n  onMounted,\n  onScopeDispose,\n  reactive,\n  shallowRef,\n  toValue,\n  useId,\n  watch,\n  type InjectionKey,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from 'vue';\n\n/**\n * Defines the arrow-key navigation axis of a roving-focus group.\n *\n * Diverges from the shared `Orientation` (foundation/utils) by adding `Both`\n * (2-D grids like ColorSwatchPicker) — stays local per the enum-alignment\n * divergence rule.\n */\nexport const Orientation = {\n  /** Refers to left/right arrow navigation only. */\n  Horizontal: 'horizontal',\n  /** Refers to up/down arrow navigation only. */\n  Vertical: 'vertical',\n  /** Refers to both-axis (grid) arrow navigation. */\n  Both: 'both',\n} as const;\n\nexport type Orientation = (typeof Orientation)[keyof typeof Orientation];\n\nexport interface ItemEntry {\n  id: string;\n  node: HTMLElement | null;\n}\n\n/**\n * Disabled state is read from the DOM node rather than a hook option, so\n * items keep declaring it the way they already do (native `disabled`,\n * `aria-disabled=\"true\"`, or a bare `data-disabled` attr) and the group sees\n * changes without re-registration.\n */\nexport function isNodeDisabled(node: HTMLElement | null): boolean {\n  if (!node) return false;\n  return (\n    node.matches(':disabled') ||\n    node.getAttribute('aria-disabled') === 'true' ||\n    node.hasAttribute('data-disabled')\n  );\n}\n\nexport const isEntryDisabled = (entry: ItemEntry): boolean => isNodeDisabled(entry.node);\n\n/**\n * First enabled entry walking from `start` (inclusive) in direction `dir`.\n * Wraps at the edges when `loop`, otherwise stops there. Returns undefined\n * when no enabled entry is reachable.\n */\nexport function findEnabled(\n  list: ReadonlyArray<ItemEntry>,\n  start: number,\n  dir: 1 | -1,\n  loop: boolean,\n): ItemEntry | undefined {\n  const len = list.length;\n  if (len === 0) return undefined;\n  for (let step = 0; step < len; step++) {\n    let index = start + dir * step;\n    if (loop) index = ((index % len) + len) % len;\n    else if (index < 0 || index >= len) return undefined;\n    const entry = list[index];\n    if (entry && !isEntryDisabled(entry)) return entry;\n  }\n  return undefined;\n}\n\n/** Nearest enabled entry around `idx` (excluding it), preferring the next one on ties. */\nexport function findNearestEnabled(\n  list: ReadonlyArray<ItemEntry>,\n  idx: number,\n): ItemEntry | undefined {\n  for (let distance = 1; distance < list.length; distance++) {\n    const forward = list[idx + distance];\n    if (forward && !isEntryDisabled(forward)) return forward;\n    const backward = list[idx - distance];\n    if (backward && !isEntryDisabled(backward)) return backward;\n  }\n  return undefined;\n}\n\nexport interface RovingFocusContextValue {\n  register: (id: string, node: HTMLElement | null) => void;\n  unregister: (id: string) => void;\n  focusedId: Readonly<ShallowRef<string | null>>;\n  setFocusedId: (id: string) => void;\n  onItemKeyDown: (event: KeyboardEvent, id: string) => void;\n  /** Re-validates that the tab stop sits on an enabled item (see useRovingFocusItem). */\n  ensureEnabledStop: (id: string) => void;\n\n  /** True once the user has interacted with the group; reset when focus leaves. */\n  interacted: ShallowRef<boolean>;\n  groupEl: Readonly<ShallowRef<HTMLElement | null>>;\n}\n\nexport const RovingFocusKey: InjectionKey<RovingFocusContextValue> = Symbol('wow-two.rovingFocus');\n\nexport interface UseRovingFocusItemOptions {\n  /** Preferred tab stop while focus is outside the group (e.g. the selected tab) — APG composite-widget pattern. Accepts a ref or getter. */\n  isActive?: MaybeRefOrGetter<boolean>;\n}\n\nexport interface UseRovingFocusItemReturn {\n  /** Function ref for the item's element — spread with `v-bind`, or bind explicitly with `:ref`. */\n  ref: (node: unknown) => void;\n  tabindex: 0 | -1;\n  onKeydown: (event: KeyboardEvent) => void;\n  onFocus: () => void;\n  'data-roving-focus-item': boolean;\n}\n\n/** A function ref may receive a component's public instance; the group needs the DOM node. */\nfunction toElement(value: unknown): HTMLElement | null {\n  if (value instanceof HTMLElement) return value;\n  const el = (value as { $el?: unknown } | null)?.$el;\n  return el instanceof HTMLElement ? el : null;\n}\n\n/**\n * Inside a `RovingFocusGroup`, returns props to bind onto a focusable item.\n * Outside, returns inert props (tabindex 0).\n *\n * ```vue\n * <button v-bind=\"item\">…</button>\n * ```\n *\n * The returned object is `reactive` — `tabindex` tracks the group's tab stop,\n * so bind the object rather than destructuring it.\n */\nexport function useRovingFocusItem(\n  options: UseRovingFocusItemOptions = {},\n): UseRovingFocusItemReturn {\n  const context = inject(RovingFocusKey, null);\n  const id = useId();\n  const node = shallowRef<HTMLElement | null>(null);\n\n  let observer: MutationObserver | null = null;\n\n  onMounted(() => {\n    const el = node.value;\n    context?.register(id, el);\n    // Disabled state lives on the DOM node (`disabled` / `aria-disabled` /\n    // `data-disabled`) and can change without re-registering. React re-validated\n    // after every render; Vue has no every-render hook, so the node is observed\n    // directly — narrower, and it catches changes React's render-driven check\n    // would have missed entirely (an attribute set outside Vue).\n    context?.ensureEnabledStop(id);\n    if (!el || !context) return;\n    observer = new MutationObserver(() => context.ensureEnabledStop(id));\n    observer.observe(el, {\n      attributes: true,\n      attributeFilter: ['disabled', 'aria-disabled', 'data-disabled'],\n    });\n  });\n\n  onScopeDispose(() => {\n    observer?.disconnect();\n    observer = null;\n    context?.unregister(id);\n  });\n\n  // Move DOM focus only after user interaction — never on initial mount.\n  watch(\n    () => context?.focusedId.value,\n    (focusedId) => {\n      if (\n        focusedId === id &&\n        context?.interacted.value &&\n        node.value &&\n        document.activeElement !== node.value\n      ) {\n        node.value.focus();\n      }\n    },\n    { flush: 'post' },\n  );\n\n  // Keep the active item (e.g. selected tab) as the tab stop whenever focus\n  // is outside the group. The group element is watched alongside `isActive`\n  // because it is null until mount — React read it from a ref after commit.\n  watch(\n    [() => toValue(options.isActive ?? false), () => context?.groupEl.value ?? null],\n    ([isActive, groupNode], _previous, onCleanup) => {\n      if (!isActive || !context || !groupNode || typeof document === 'undefined') return;\n      if (!groupNode.contains(document.activeElement)) context.setFocusedId(id);\n      const onFocusOut = (event: FocusEvent) => {\n        const next = event.relatedTarget as Node | null;\n        if (!next || !groupNode.contains(next)) context.setFocusedId(id);\n      };\n      groupNode.addEventListener('focusout', onFocusOut);\n      onCleanup(() => groupNode.removeEventListener('focusout', onFocusOut));\n    },\n    { immediate: true, flush: 'post' },\n  );\n\n  return reactive({\n    ref: (value: unknown) => {\n      node.value = toElement(value);\n    },\n    tabindex: computed<0 | -1>(() => (!context || context.focusedId.value === id ? 0 : -1)),\n    onKeydown: (event: KeyboardEvent) => context?.onItemKeyDown(event, id),\n    onFocus: () => {\n      if (!context) return;\n      context.interacted.value = true;\n      context.setFocusedId(id);\n    },\n    'data-roving-focus-item': true,\n  }) as UseRovingFocusItemReturn;\n}\n","<script lang=\"ts\">\nimport type { HTMLAttributes } from 'vue';\n\n// `Orientation` is imported as a value by `<script setup>` below; both blocks\n// share one module scope, so re-importing the type here would duplicate it.\nexport interface RovingFocusGroupProps extends /* @vue-ignore */ HTMLAttributes {\n  orientation?: Orientation;\n  canLoop?: boolean;\n}\n</script>\n\n<script setup lang=\"ts\">\nimport { provide, shallowRef, useTemplateRef, watch } from 'vue';\nimport { Direction, useDirection } from '../directionProvider';\nimport {\n  Orientation,\n  RovingFocusKey,\n  findEnabled,\n  findNearestEnabled,\n  isEntryDisabled,\n  isNodeDisabled,\n  type ItemEntry,\n  type RovingFocusContextValue,\n} from './RovingFocusContext';\n\n/**\n * Provide arrow-key navigation for a group of focusable children. Children\n * call `useRovingFocusItem()` to register and receive `tabindex` / event\n * handlers. Disabled items (native `disabled`, `aria-disabled=\"true\"`, or\n * `data-disabled`) are never valid stops: arrow / Home / End navigation\n * skips them (wrap-around keeps skipping past disabled edges) and the tab\n * stop is always kept on an enabled item. Used by Tabs, Toolbar, Tree,\n * Accordion, Stepper, NavigationMenu, Menubar.\n */\ndefineOptions({ name: 'RovingFocusGroup' });\n\nconst props = withDefaults(defineProps<RovingFocusGroupProps>(), {\n  orientation: Orientation.Horizontal,\n  canLoop: true,\n});\n\n// Typed as `HTMLElement`, not `HTMLDivElement` — `ShallowRef` is invariant, so\n// the narrower element type would not satisfy the context's `groupEl`.\nconst groupEl = useTemplateRef<HTMLElement>('groupEl');\n/** Plain array, not reactive — the ordering is read imperatively, exactly as React's `useRef` list was. */\nconst items: Array<ItemEntry> = [];\nconst focusedId = shallowRef<string | null>(null);\nconst interacted = shallowRef(false);\nconst direction = useDirection();\n\nfunction setFocusedId(id: string): void {\n  focusedId.value = id;\n}\n\nfunction register(id: string, node: HTMLElement | null): void {\n  if (!items.some((item) => item.id === id)) {\n    const entry: ItemEntry = { id, node };\n    // Insert by DOM order (not mount order) so dynamically inserted\n    // items navigate in visual order.\n    const index = node\n      ? items.findIndex(\n          (item) =>\n            item.node !== null &&\n            (node.compareDocumentPosition(item.node) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0,\n        )\n      : -1;\n    if (index === -1) items.push(entry);\n    else items.splice(index, 0, entry);\n  }\n  // A disabled item never claims the tab stop — tabindex 0 on an\n  // unfocusable element would make the whole group untabbable.\n  if (!isNodeDisabled(node)) focusedId.value = focusedId.value ?? id;\n}\n\nfunction unregister(id: string): void {\n  const idx = items.findIndex((item) => item.id === id);\n  if (idx >= 0) items.splice(idx, 1);\n  // If the tab stop unmounts, advance to the next remaining enabled item\n  // (wrapping to the first) so the group keeps exactly one tabbable item.\n  if (focusedId.value === id) {\n    const next = findEnabled(items, idx, 1, true);\n    focusedId.value = next ? next.id : null;\n  }\n}\n\n// Reset the interaction flag when focus leaves the group so tab-stop\n// bookkeeping (focusedId updates) never steals focus back.\nwatch(\n  groupEl,\n  (node, _previous, onCleanup) => {\n    if (!node) return;\n    const onFocusOut = (event: FocusEvent) => {\n      const next = event.relatedTarget as Node | null;\n      if (!next || !node.contains(next)) interacted.value = false;\n    };\n    node.addEventListener('focusout', onFocusOut);\n    onCleanup(() => node.removeEventListener('focusout', onFocusOut));\n  },\n  { immediate: true },\n);\n\nfunction onItemKeyDown(event: KeyboardEvent, id: string): void {\n  const idx = items.findIndex((item) => item.id === id);\n  if (idx === -1) return;\n  const isVert =\n    props.orientation === Orientation.Vertical || props.orientation === Orientation.Both;\n  const isHoriz =\n    props.orientation === Orientation.Horizontal || props.orientation === Orientation.Both;\n  // Horizontal arrows mirror in RTL.\n  const nextHorizKey = direction.value === Direction.Rtl ? 'ArrowLeft' : 'ArrowRight';\n  const prevHorizKey = direction.value === Direction.Rtl ? 'ArrowRight' : 'ArrowLeft';\n  // Disabled items are skipped (APG): the search walks past them —\n  // wrapping at the edges when canLoop — until an enabled item is\n  // found; Home / End land on the first / last *enabled* item.\n  let next: ItemEntry | undefined;\n  if ((event.key === nextHorizKey && isHoriz) || (event.key === 'ArrowDown' && isVert)) {\n    next = findEnabled(items, idx + 1, 1, props.canLoop);\n  } else if ((event.key === prevHorizKey && isHoriz) || (event.key === 'ArrowUp' && isVert)) {\n    next = findEnabled(items, idx - 1, -1, props.canLoop);\n  } else if (event.key === 'Home') {\n    next = findEnabled(items, 0, 1, false);\n  } else if (event.key === 'End') {\n    next = findEnabled(items, items.length - 1, -1, false);\n  } else {\n    return;\n  }\n  event.preventDefault();\n  interacted.value = true;\n  if (next) focusedId.value = next.id;\n}\n\n// Items call this on mount and whenever their disabled attributes mutate —\n// keeps the tab stop off disabled items even when disabled state toggles\n// long after registration.\nfunction ensureEnabledStop(id: string): void {\n  const caller = items.find((item) => item.id === id);\n  if (!caller) return;\n  const current = focusedId.value;\n  // No stop is held (every item registered disabled) — the first\n  // enabled caller claims it.\n  if (current === null) {\n    focusedId.value = isEntryDisabled(caller) ? null : id;\n    return;\n  }\n  // The held stop turned disabled — hand it to the nearest enabled item.\n  const heldIdx = items.findIndex((item) => item.id === current);\n  const held = heldIdx === -1 ? undefined : items[heldIdx];\n  if (held && isEntryDisabled(held)) {\n    const next = findNearestEnabled(items, heldIdx);\n    focusedId.value = next ? next.id : null;\n  }\n}\n\nconst context: RovingFocusContextValue = {\n  register,\n  unregister,\n  focusedId,\n  setFocusedId,\n  onItemKeyDown,\n  ensureEnabledStop,\n  interacted,\n  groupEl,\n};\n\nprovide(RovingFocusKey, context);\n\ndefineExpose({ el: groupEl });\n</script>\n\n<template>\n  <div ref=\"groupEl\" role=\"group\"><slot /></div>\n</template>\n"],"names":["_createElementBlock","_renderSlot"],"mappings":"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"}

package/dist/chunks/ScrollLockProvider.vue_vue_type_script_setup_true_lang-_ihHJ7jI.js

@@ -0,0 +1,20 @@
+import { defineComponent, renderSlot } from "vue";
+import { u as useScrollLock } from "./useScrollLock-d6YIGUcs.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "ScrollLockProvider" },
+  __name: "ScrollLockProvider",
+  props: {
+    isEnabled: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    useScrollLock(() => props.isEnabled);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  _sfc_main as _
+};
+//# sourceMappingURL=ScrollLockProvider.vue_vue_type_script_setup_true_lang-_ihHJ7jI.js.map

package/dist/chunks/ScrollLockProvider.vue_vue_type_script_setup_true_lang-_ihHJ7jI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScrollLockProvider.vue_vue_type_script_setup_true_lang-_ihHJ7jI.js","sources":["../../src/foundation/primitives/scrollLockProvider/ScrollLockProvider.vue"],"sourcesContent":["<script lang=\"ts\">\nexport interface ScrollLockProviderProps {\n  isEnabled?: boolean;\n}\n</script>\n\n<script setup lang=\"ts\">\nimport { useScrollLock } from '../../hooks/useScrollLock';\n\n/**\n * Component wrapper around `useScrollLock` — handy when scroll lock should\n * follow a child's mount lifecycle (e.g. inside a Modal's teleport).\n * Multiple wrappers stack; lock releases when the count reaches zero.\n *\n * Renders nothing of its own: the slot is returned as-is, so this component is\n * transparent to layout (React returned a bare fragment for the same reason).\n */\ndefineOptions({ name: 'ScrollLockProvider' });\n\nconst props = withDefaults(defineProps<ScrollLockProviderProps>(), { isEnabled: true });\n\n// Passed as a getter so the lock follows the prop, matching the React effect's\n// `[enabled]` dependency.\nuseScrollLock(() => props.isEnabled);\n</script>\n\n<template>\n  <slot />\n</template>\n"],"names":["_renderSlot"],"mappings":";;;;;;;;;AAmBA,UAAM,QAAQ;AAId,kBAAc,MAAM,MAAM,SAAS;;aAIjCA,WAAQ,KAAA,QAAA,SAAA;AAAA;;;"}

package/dist/chunks/SerializeError-CclP2jCW.js

@@ -0,0 +1,61 @@
+import { b as isObjectLike, r as readMember } from "./ErrorLike-Cfj0lZW3.js";
+import { t as toError, U as UnknownErrorMessage } from "./ToError-CyTBsmLO.js";
+const DefaultMaxCauseDepth = 8;
+function resolveCap(maxDepth) {
+  return Number.isFinite(maxDepth) ? Math.max(1, Math.trunc(maxDepth)) : DefaultMaxCauseDepth;
+}
+function getErrorCause(error) {
+  return isObjectLike(error) ? readMember(error, "cause") : void 0;
+}
+function flattenErrorChain(error, maxDepth = DefaultMaxCauseDepth) {
+  try {
+    const cap = resolveCap(maxDepth);
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = error;
+    while (chain.length < cap) {
+      if (isObjectLike(current)) {
+        if (seen.has(current)) break;
+        seen.add(current);
+      }
+      chain.push(toError(current));
+      const cause = getErrorCause(current);
+      if (cause === void 0 || cause === null) break;
+      current = cause;
+    }
+    return chain;
+  } catch {
+    return [toError(error)];
+  }
+}
+function projectLink(error, cause) {
+  const name = readMember(error, "name");
+  const message = readMember(error, "message");
+  const stack = readMember(error, "stack");
+  const code = readMember(error, "code");
+  return {
+    name: typeof name === "string" && name !== "" ? name : "Error",
+    message: typeof message === "string" ? message : "",
+    ...typeof stack === "string" && stack !== "" ? { stack } : {},
+    ...typeof code === "string" || typeof code === "number" ? { code } : {},
+    ...cause !== void 0 ? { cause } : {}
+  };
+}
+function serializeError(error, maxDepth = DefaultMaxCauseDepth) {
+  try {
+    let serialized;
+    for (const link of [...flattenErrorChain(error, maxDepth)].reverse()) {
+      serialized = projectLink(link, serialized);
+    }
+    return serialized ?? { name: "Error", message: UnknownErrorMessage };
+  } catch {
+    return { name: "Error", message: UnknownErrorMessage };
+  }
+}
+export {
+  DefaultMaxCauseDepth as D,
+  flattenErrorChain as f,
+  getErrorCause as g,
+  serializeError as s
+};
+//# sourceMappingURL=SerializeError-CclP2jCW.js.map

package/dist/chunks/SerializeError-CclP2jCW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SerializeError-CclP2jCW.js","sources":["../../src/foundation/errors/ErrorChain.ts","../../src/foundation/errors/SerializeError.ts"],"sourcesContent":["import { isObjectLike, readMember } from './ErrorLike';\nimport { toError } from './ToError';\n\n/**\n * Provides the default cap on how many links a `cause` walk yields. Bounds both a pathological chain\n * and the size of anything built from one (a log payload, a rendered detail list); 8 covers every real\n * wrap depth seen in practice with room to spare.\n */\nexport const DefaultMaxCauseDepth = 8;\n\n/** Resolves a caller-supplied cap to a usable one — at least 1 link (the head is always returned), and never `NaN` / `Infinity`. */\nfunction resolveCap(maxDepth: number): number {\n  return Number.isFinite(maxDepth) ? Math.max(1, Math.trunc(maxDepth)) : DefaultMaxCauseDepth;\n}\n\n/**\n * Reads the underlying failure a value wraps — the standard ES2022 `cause`, as thrown\n * (`new Error(msg, { cause })`). Returns the raw value, not an `Error`: a `cause` can be anything,\n * and normalizing it here would hide what was actually attached. `undefined` when there is none.\n *\n * Never throws — a `cause` getter that throws reads as absent.\n */\nexport function getErrorCause(error: unknown): unknown {\n  return isObjectLike(error) ? readMember(error, 'cause') : undefined;\n}\n\n/**\n * Walks the `cause` chain from an error down to its root, normalizing each link with `toError`, and\n * returns the links head-first. Always non-empty — the head normalizes even from `undefined`.\n *\n * Terminates on every input. Links are tracked by identity, so a self-referencing (`error.cause ===\n * error`) or mutually-referencing chain stops at the repeat instead of hanging, and `maxDepth` caps\n * the rest. Truncation is silent: the tail simply has no further links.\n */\nexport function flattenErrorChain(error: unknown, maxDepth: number = DefaultMaxCauseDepth): Error[] {\n  try {\n    const cap = resolveCap(maxDepth);\n    const chain: Error[] = [];\n    // Identity set over the RAW links, not the normalized ones: `toError` mints a fresh `Error` for\n    // every non-`Error` link, so normalized identity would never repeat and never detect a cycle.\n    const seen = new Set<unknown>();\n    let current: unknown = error;\n\n    while (chain.length < cap) {\n      if (isObjectLike(current)) {\n        if (seen.has(current)) break;\n        seen.add(current);\n      }\n      chain.push(toError(current));\n\n      const cause = getErrorCause(current);\n      // A primitive link can carry no `cause`, so the walk always reaches this exit.\n      if (cause === undefined || cause === null) break;\n      current = cause;\n    }\n\n    return chain;\n  } catch {\n    return [toError(error)];\n  }\n}\n","import { DefaultMaxCauseDepth, flattenErrorChain } from './ErrorChain';\nimport { readMember } from './ErrorLike';\nimport { UnknownErrorMessage } from './ToError';\n\n/** Defines the JSON-safe projection of an error produced by {@link serializeError}. Every member is a plain value — no getters, no prototype, no cycles. */\nexport interface SerializedError {\n  /** The error kind — the source's `name`, or `'Error'` when it had none. */\n  readonly name: string;\n\n  /** The failure description — the source's `message`, or `''` when it had none (this is a log record, not UI copy). */\n  readonly message: string;\n\n  /** The captured stack trace. Omitted when the source had none. */\n  readonly stack?: string;\n\n  /** The machine-readable code. Omitted unless the source carried a string or number `code` — other types are dropped to keep the payload JSON-safe. */\n  readonly code?: string | number;\n\n  /** The serialized underlying failure. Omitted at the root of the chain, and wherever the depth cap or a cycle stopped the walk. */\n  readonly cause?: SerializedError;\n}\n\n/** Projects one normalized link, hanging the already-serialized inner link off it. */\nfunction projectLink(error: Error, cause: SerializedError | undefined): SerializedError {\n  const name = readMember(error, 'name');\n  const message = readMember(error, 'message');\n  const stack = readMember(error, 'stack');\n  const code = readMember(error, 'code');\n\n  return {\n    name: typeof name === 'string' && name !== '' ? name : 'Error',\n    message: typeof message === 'string' ? message : '',\n    ...(typeof stack === 'string' && stack !== '' ? { stack } : {}),\n    ...(typeof code === 'string' || typeof code === 'number' ? { code } : {}),\n    ...(cause !== undefined ? { cause } : {}),\n  };\n}\n\n/**\n * Projects any caught value into a plain object safe to hand a logger or a telemetry sink — an `Error`\n * serializes to `{}` through `JSON.stringify`, because `name` / `message` / `stack` are all\n * non-enumerable, so anything that ships errors off the device needs this first.\n *\n * The `cause` chain nests, inheriting the walk's cycle protection and depth cap, so a circular\n * `cause` produces a finite tree rather than a `JSON.stringify` overflow. Non-JSON-safe members are\n * dropped, not coerced: the result always survives `JSON.stringify`.\n *\n * Never throws.\n */\nexport function serializeError(error: unknown, maxDepth: number = DefaultMaxCauseDepth): SerializedError {\n  try {\n    let serialized: SerializedError | undefined;\n    // Fold from the root back to the head, so each link is built with its inner one already done.\n    for (const link of [...flattenErrorChain(error, maxDepth)].reverse()) {\n      serialized = projectLink(link, serialized);\n    }\n    // `flattenErrorChain` is non-empty by contract; the fallback keeps the return type honest.\n    return serialized ?? { name: 'Error', message: UnknownErrorMessage };\n  } catch {\n    return { name: 'Error', message: UnknownErrorMessage };\n  }\n}\n"],"names":[],"mappings":";;AAQO,MAAM,uBAAuB;AAGpC,SAAS,WAAW,UAA0B;AAC5C,SAAO,OAAO,SAAS,QAAQ,IAAI,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,CAAC,IAAI;AACzE;AASO,SAAS,cAAc,OAAyB;AACrD,SAAO,aAAa,KAAK,IAAI,WAAW,OAAO,OAAO,IAAI;AAC5D;AAUO,SAAS,kBAAkB,OAAgB,WAAmB,sBAA+B;AAClG,MAAI;AACF,UAAM,MAAM,WAAW,QAAQ;AAC/B,UAAM,QAAiB,CAAA;AAGvB,UAAM,2BAAW,IAAA;AACjB,QAAI,UAAmB;AAEvB,WAAO,MAAM,SAAS,KAAK;AACzB,UAAI,aAAa,OAAO,GAAG;AACzB,YAAI,KAAK,IAAI,OAAO,EAAG;AACvB,aAAK,IAAI,OAAO;AAAA,MAClB;AACA,YAAM,KAAK,QAAQ,OAAO,CAAC;AAE3B,YAAM,QAAQ,cAAc,OAAO;AAEnC,UAAI,UAAU,UAAa,UAAU,KAAM;AAC3C,gBAAU;AAAA,IACZ;AAEA,WAAO;AAAA,EACT,QAAQ;AACN,WAAO,CAAC,QAAQ,KAAK,CAAC;AAAA,EACxB;AACF;ACrCA,SAAS,YAAY,OAAc,OAAqD;AACtF,QAAM,OAAO,WAAW,OAAO,MAAM;AACrC,QAAM,UAAU,WAAW,OAAO,SAAS;AAC3C,QAAM,QAAQ,WAAW,OAAO,OAAO;AACvC,QAAM,OAAO,WAAW,OAAO,MAAM;AAErC,SAAO;AAAA,IACL,MAAM,OAAO,SAAS,YAAY,SAAS,KAAK,OAAO;AAAA,IACvD,SAAS,OAAO,YAAY,WAAW,UAAU;AAAA,IACjD,GAAI,OAAO,UAAU,YAAY,UAAU,KAAK,EAAE,MAAA,IAAU,CAAA;AAAA,IAC5D,GAAI,OAAO,SAAS,YAAY,OAAO,SAAS,WAAW,EAAE,KAAA,IAAS,CAAA;AAAA,IACtE,GAAI,UAAU,SAAY,EAAE,UAAU,CAAA;AAAA,EAAC;AAE3C;AAaO,SAAS,eAAe,OAAgB,WAAmB,sBAAuC;AACvG,MAAI;AACF,QAAI;AAEJ,eAAW,QAAQ,CAAC,GAAG,kBAAkB,OAAO,QAAQ,CAAC,EAAE,WAAW;AACpE,mBAAa,YAAY,MAAM,UAAU;AAAA,IAC3C;AAEA,WAAO,cAAc,EAAE,MAAM,SAAS,SAAS,oBAAA;AAAA,EACjD,QAAQ;AACN,WAAO,EAAE,MAAM,SAAS,SAAS,oBAAA;AAAA,EACnC;AACF;"}

package/dist/chunks/Severity-D0C5oAt-.js

@@ -0,0 +1,16 @@
+const Severity = {
+  /** Refers to a neutral, non-semantic message. */
+  Neutral: "neutral",
+  /** Refers to an informational message. */
+  Info: "info",
+  /** Refers to a positive / success message. */
+  Success: "success",
+  /** Refers to a caution / warning message. */
+  Warning: "warning",
+  /** Refers to a destructive / error message. */
+  Danger: "danger"
+};
+export {
+  Severity as S
+};
+//# sourceMappingURL=Severity-D0C5oAt-.js.map

package/dist/chunks/Severity-D0C5oAt-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Severity-D0C5oAt-.js","sources":["../../src/foundation/utils/Severity/Severity.ts"],"sourcesContent":["/* Provides the shared severity vocabulary for status-bearing feedback surfaces. */\n\n/** Defines the severity of a feedback surface (alert / banner / toast / callout). */\nexport const Severity = {\n  /** Refers to a neutral, non-semantic message. */\n  Neutral: 'neutral',\n  /** Refers to an informational message. */\n  Info: 'info',\n  /** Refers to a positive / success message. */\n  Success: 'success',\n  /** Refers to a caution / warning message. */\n  Warning: 'warning',\n  /** Refers to a destructive / error message. */\n  Danger: 'danger',\n} as const;\n\nexport type Severity = (typeof Severity)[keyof typeof Severity];\n"],"names":[],"mappings":"AAGO,MAAM,WAAW;AAAA;AAAA,EAEtB,SAAS;AAAA;AAAA,EAET,MAAM;AAAA;AAAA,EAEN,SAAS;AAAA;AAAA,EAET,SAAS;AAAA;AAAA,EAET,QAAQ;AACV;"}

package/dist/chunks/Side-CSys3p-F.js

@@ -0,0 +1,23 @@
+function composeEventHandlers(theirHandler, ourHandler, { checkForDefaultPrevented = true } = {}) {
+  return (event) => {
+    theirHandler?.(event);
+    if (!checkForDefaultPrevented || !event.defaultPrevented) {
+      ourHandler(event);
+    }
+  };
+}
+const Side = {
+  /** Refers to the top side. */
+  Top: "top",
+  /** Refers to the right side. */
+  Right: "right",
+  /** Refers to the bottom side. */
+  Bottom: "bottom",
+  /** Refers to the left side. */
+  Left: "left"
+};
+export {
+  Side as S,
+  composeEventHandlers as c
+};
+//# sourceMappingURL=Side-CSys3p-F.js.map

package/dist/chunks/Side-CSys3p-F.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Side-CSys3p-F.js","sources":["../../src/foundation/utils/composeEventHandlers/composeEventHandlers.ts","../../src/foundation/utils/Side/Side.ts"],"sourcesContent":["/**\n * Chain two event handlers. The first handler runs, then the second — unless\n * the first called `event.preventDefault()`, in which case the second is skipped.\n * Use when overriding a default handler from a parent while still allowing\n * the consumer to provide their own.\n */\nexport function composeEventHandlers<E extends Event>(\n  theirHandler: ((event: E) => void) | undefined,\n  ourHandler: (event: E) => void,\n  { checkForDefaultPrevented = true }: { checkForDefaultPrevented?: boolean } = {},\n): (event: E) => void {\n  return (event) => {\n    theirHandler?.(event);\n    if (!checkForDefaultPrevented || !event.defaultPrevented) {\n      ourHandler(event);\n    }\n  };\n}\n","/* Provides the shared box-side vocabulary (DrawerSide / chevronSide / switchField side / twoColumn asideSide). */\n\n/** Defines a side of a box. */\nexport const Side = {\n  /** Refers to the top side. */\n  Top: 'top',\n  /** Refers to the right side. */\n  Right: 'right',\n  /** Refers to the bottom side. */\n  Bottom: 'bottom',\n  /** Refers to the left side. */\n  Left: 'left',\n} as const;\n\nexport type Side = (typeof Side)[keyof typeof Side];\n"],"names":[],"mappings":"AAMO,SAAS,qBACd,cACA,YACA,EAAE,2BAA2B,KAAA,IAAiD,IAC1D;AACpB,SAAO,CAAC,UAAU;AAChB,mBAAe,KAAK;AACpB,QAAI,CAAC,4BAA4B,CAAC,MAAM,kBAAkB;AACxD,iBAAW,KAAK;AAAA,IAClB;AAAA,EACF;AACF;ACdO,MAAM,OAAO;AAAA;AAAA,EAElB,KAAK;AAAA;AAAA,EAEL,OAAO;AAAA;AAAA,EAEP,QAAQ;AAAA;AAAA,EAER,MAAM;AACR;"}

package/dist/chunks/Slot-D2lIitvV.js

@@ -0,0 +1,103 @@
+import { defineComponent, normalizeClass, normalizeStyle, Fragment, Comment, createTextVNode, h, Text } from "vue";
+function toHandlers(value) {
+  if (Array.isArray(value)) return value.filter((handler) => typeof handler === "function");
+  return typeof value === "function" ? [value] : [];
+}
+function mergeProps(slotProps, childProps) {
+  const merged = { ...childProps };
+  for (const key of Object.keys(slotProps)) {
+    const slotVal = slotProps[key];
+    const childVal = childProps[key];
+    if (key === "class") {
+      merged.class = normalizeClass([slotVal, childVal]);
+    } else if (key === "style") {
+      merged.style = normalizeStyle([slotVal, childVal]);
+    } else if (/^on[A-Z]/.test(key)) {
+      const slotFns = toHandlers(slotVal);
+      const childFns = toHandlers(childVal);
+      if (slotFns.length > 0 && childFns.length > 0) {
+        merged[key] = [...childFns, ...slotFns];
+      } else if (slotFns.length > 0) {
+        merged[key] = slotVal;
+      }
+    } else if (childVal === void 0) {
+      merged[key] = slotVal;
+    }
+  }
+  return merged;
+}
+function isBlankText(vnode) {
+  return vnode.type === Text && typeof vnode.children === "string" && vnode.children.trim() === "";
+}
+function renderableChildren(nodes) {
+  const flattened = [];
+  for (const node of nodes ?? []) {
+    if (node === null || node === void 0 || typeof node === "boolean") continue;
+    if (Array.isArray(node)) {
+      flattened.push(...renderableChildren(node));
+      continue;
+    }
+    const vnode = node;
+    if (vnode.type === Fragment) {
+      flattened.push(
+        ...renderableChildren(Array.isArray(vnode.children) ? vnode.children : void 0)
+      );
+      continue;
+    }
+    if (vnode.type === Comment || isBlankText(vnode)) continue;
+    flattened.push(vnode);
+  }
+  return flattened;
+}
+function isComponentVNode(vnode) {
+  return typeof vnode.type !== "string";
+}
+function ownChildren(vnode) {
+  const { children } = vnode;
+  if (children === null || children === void 0) return [];
+  if (typeof children === "string") return [createTextVNode(children)];
+  if (Array.isArray(children)) return renderableChildren(children);
+  const defaultSlot = children.default;
+  return typeof defaultSlot === "function" ? renderableChildren(defaultSlot()) : [];
+}
+function rebuild(target, props, children) {
+  const rebuilt = h(target.type, props, children);
+  rebuilt.ref = target.ref;
+  rebuilt.key = target.key;
+  return rebuilt;
+}
+const Slottable = defineComponent({
+  name: "Slottable",
+  setup(_props, { slots }) {
+    return () => slots.default?.() ?? null;
+  }
+});
+function renderSlotClone(slotProps, slots) {
+  const children = renderableChildren(slots.default?.());
+  const slottable = children.find((child2) => child2.type === Slottable);
+  if (slottable) {
+    const target = ownChildren(slottable)[0];
+    if (!target) return null;
+    const targetChildren = ownChildren(target);
+    const newChildren = children.flatMap(
+      (child2) => child2 === slottable ? targetChildren : [child2]
+    );
+    const merged2 = mergeProps(slotProps, target.props ?? {});
+    return rebuild(
+      target,
+      merged2,
+      isComponentVNode(target) ? { default: () => newChildren } : newChildren
+    );
+  }
+  const child = children[0];
+  if (!child) return null;
+  const merged = mergeProps(slotProps, child.props ?? {});
+  return rebuild(child, merged, child.children);
+}
+export {
+  Slottable as S,
+  renderSlotClone as a,
+  mergeProps as m,
+  renderableChildren as r
+};
+//# sourceMappingURL=Slot-D2lIitvV.js.map

package/dist/chunks/Slot-D2lIitvV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slot-D2lIitvV.js","sources":["../../src/foundation/primitives/slot/Slot.ts"],"sourcesContent":["import {\n  Comment,\n  Fragment,\n  Text,\n  createTextVNode,\n  defineComponent,\n  h,\n  normalizeClass,\n  normalizeStyle,\n  type Slots,\n  type VNode,\n  type VNodeArrayChildren,\n} from 'vue';\n\nexport type AnyProps = Record<string, unknown>;\n\n/**\n * Vue keeps a vnode's listeners under the same `on[A-Z]` prop shape React uses\n * (`@click` compiles to `onClick`), but a single prop may hold *several*\n * handlers as an array. Normalize both sides before chaining so a child that\n * already carries two listeners doesn't lose one.\n */\nfunction toHandlers(value: unknown): ReadonlyArray<unknown> {\n  if (Array.isArray(value)) return value.filter((handler) => typeof handler === 'function');\n  return typeof value === 'function' ? [value] : [];\n}\n\n/**\n * Merge the slot's own props into the child element's props. Port of the React\n * `Slot`'s `mergeProps`, semantics preserved exactly:\n *\n * - `class` — concatenated, slot first (React's `className`, same order).\n * - `style` — shallow-merged, **child wins** on a key collision.\n * - `on[A-Z]*` — chained **child first, then slot**. Vue invokes an array of\n *   handlers in order, so the chain is expressed as an array rather than React's\n *   wrapper closure — same call order, and each handler stays inspectable.\n * - everything else — the child's value wins whenever it is defined.\n */\nexport function mergeProps(slotProps: AnyProps, childProps: AnyProps): AnyProps {\n  const merged: AnyProps = { ...childProps };\n  for (const key of Object.keys(slotProps)) {\n    const slotVal = slotProps[key];\n    const childVal = childProps[key];\n    if (key === 'class') {\n      merged.class = normalizeClass([slotVal, childVal]);\n    } else if (key === 'style') {\n      // `normalizeStyle` merges left → right, so the child's declarations land last.\n      merged.style = normalizeStyle([slotVal, childVal]);\n    } else if (/^on[A-Z]/.test(key)) {\n      const slotFns = toHandlers(slotVal);\n      const childFns = toHandlers(childVal);\n      if (slotFns.length > 0 && childFns.length > 0) {\n        merged[key] = [...childFns, ...slotFns];\n      } else if (slotFns.length > 0) {\n        merged[key] = slotVal;\n      }\n    } else if (childVal === undefined) {\n      merged[key] = slotVal;\n    }\n  }\n  return merged;\n}\n\n/** A whitespace-only text vnode — the compiler emits these between elements; they are not merge targets. */\nfunction isBlankText(vnode: VNode): boolean {\n  return vnode.type === Text && typeof vnode.children === 'string' && vnode.children.trim() === '';\n}\n\n/**\n * Flatten a slot's return value to the vnodes that actually render. Vue wraps\n * `v-if` / `v-for` output in `Fragment`s and emits `Comment` placeholders for a\n * false `v-if`; React's `Children.toArray` filtering has no equivalent, so the\n * walk is explicit. This is what makes \"the single child element\" well-defined.\n */\nexport function renderableChildren(nodes: VNodeArrayChildren | undefined): Array<VNode> {\n  const flattened: Array<VNode> = [];\n  for (const node of nodes ?? []) {\n    if (node === null || node === undefined || typeof node === 'boolean') continue;\n    if (Array.isArray(node)) {\n      flattened.push(...renderableChildren(node));\n      continue;\n    }\n    const vnode = node as VNode;\n    if (vnode.type === Fragment) {\n      flattened.push(\n        ...renderableChildren(Array.isArray(vnode.children) ? vnode.children : undefined),\n      );\n      continue;\n    }\n    if (vnode.type === Comment || isBlankText(vnode)) continue;\n    flattened.push(vnode);\n  }\n  return flattened;\n}\n\n/** A component vnode (as opposed to an intrinsic tag) — its children are a slots object, not an array. */\nfunction isComponentVNode(vnode: VNode): boolean {\n  return typeof vnode.type !== 'string';\n}\n\n/** The vnodes a target already renders, whether it holds text, an array, or slots. */\nfunction ownChildren(vnode: VNode): Array<VNode> {\n  const { children } = vnode;\n  if (children === null || children === undefined) return [];\n  if (typeof children === 'string') return [createTextVNode(children)];\n  if (Array.isArray(children)) return renderableChildren(children);\n  const defaultSlot = (children as Slots).default;\n  return typeof defaultSlot === 'function' ? renderableChildren(defaultSlot()) : [];\n}\n\n/**\n * Rebuild `target` with `props` and `children`.\n *\n * Deliberately **not** `cloneVNode`: that runs the extra props back through\n * Vue's own `mergeProps`, which would concatenate the child's class a second\n * time and chain an already-chained handler — double-firing every listener the\n * child declared. Building the vnode fresh keeps `mergeProps` above the single\n * authority on merge order; `ref` and `key` are carried over by hand because\n * they live on the vnode rather than in its props.\n */\nfunction rebuild(target: VNode, props: AnyProps, children: unknown): VNode {\n  const rebuilt = h(target.type as never, props, children as never);\n  rebuilt.ref = target.ref;\n  rebuilt.key = target.key;\n  return rebuilt;\n}\n\n/** `<Slottable>` takes no props — the merge target arrives through its default slot. */\nexport type SlottableProps = Record<string, never>;\n\n/**\n * Marks the merge target among a `Slot`'s children. Wrap the consumer's element\n * in `<Slottable>` when the component renders extra content (icons, adornments)\n * around it — the surrounding children then compose *inside* the cloned target,\n * so the single-child `Slot` contract is never violated.\n */\nexport const Slottable = defineComponent({\n  name: 'Slottable',\n  setup(_props, { slots }) {\n    return () => slots.default?.() ?? null;\n  },\n});\n\n/**\n * The single-child merge shared by `Slot` and `Primitive`'s `asChild` branch.\n * Resolves the merge target (honouring `<Slottable>`), merges `slotProps` into\n * it, and returns the rebuilt vnode — or `null` when the slot holds no element.\n */\nexport function renderSlotClone(slotProps: AnyProps, slots: Slots): VNode | null {\n  const children = renderableChildren(slots.default?.());\n  const slottable = children.find((child) => child.type === Slottable);\n\n  if (slottable) {\n    // The `<Slottable>`'s own child is the real merge target (e.g. a RouterLink).\n    const target = ownChildren(slottable)[0];\n    if (!target) return null;\n    // Rebuild the sibling list, swapping the `<Slottable>` placeholder for the\n    // target's original children — so the surrounding nodes compose inside the\n    // rebuilt target: [before…, …targetChildren, …after].\n    const targetChildren = ownChildren(target);\n    const newChildren = children.flatMap((child) =>\n      child === slottable ? targetChildren : [child],\n    );\n    const merged = mergeProps(slotProps, (target.props ?? {}) as AnyProps);\n    return rebuild(\n      target,\n      merged,\n      isComponentVNode(target) ? { default: () => newChildren } : newChildren,\n    );\n  }\n\n  const child = children[0];\n  if (!child) return null;\n  const merged = mergeProps(slotProps, (child.props ?? {}) as AnyProps);\n  // Pass the child's existing children straight through — for a component that\n  // is its whole slots object, so named slots survive the rebuild.\n  return rebuild(child, merged, child.children as Array<VNode> | Slots | string);\n}\n\n/*\n * There is deliberately no `Slot` component here.\n *\n * `<slot>` is a real Vue element, so a component registered as `Slot` collides\n * in every template that renders one (`vue/no-reserved-component-names`). The\n * React `Slot`'s always-clone behaviour is `<Primitive as-child>` instead —\n * see `./Primitive`. `renderSlotClone` above is the shared merge core, exported\n * for anything that needs the merge without the component wrapper.\n */\n"],"names":["child","merged"],"mappings":"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"}