@wow-two-beta/ui-vue 0.0.2

package/dist/chunks/Environment-CuQav_mw.js

@@ -0,0 +1,68 @@
+const ColorTone = {
+  /** Refers to the primary brand palette. */
+  Primary: "primary",
+  /** Refers to the neutral / default grey palette. */
+  Neutral: "neutral",
+  /** Refers to the destructive / error palette. */
+  Danger: "danger",
+  /** Refers to the positive / confirmation palette. */
+  Success: "success",
+  /** Refers to the caution palette. */
+  Warning: "warning"
+};
+const TONE_TOKEN_MAP = {
+  primary: { main: "primary", fg: "primary-foreground", soft: "primary-soft", softFg: "primary-soft-foreground" },
+  neutral: { main: "foreground", fg: "background", soft: "muted", softFg: "foreground" },
+  danger: { main: "destructive", fg: "destructive-foreground", soft: "destructive-soft", softFg: "destructive-soft-foreground" },
+  success: { main: "success", fg: "success-foreground", soft: "success-soft", softFg: "success-soft-foreground" },
+  warning: { main: "warning", fg: "warning-foreground", soft: "warning-soft", softFg: "warning-soft-foreground" }
+};
+function toneColorOverride(input, tone) {
+  if (input === void 0 || input === null) return void 0;
+  const activeTone = tone ?? "primary";
+  const tokens = TONE_TOKEN_MAP[activeTone];
+  const out = {};
+  if (typeof input === "string") {
+    out[`--color-${tokens.main}`] = input;
+    out[`--color-${tokens.fg}`] = "#ffffff";
+    out[`--color-${tokens.soft}`] = `color-mix(in oklch, ${input} 12%, white)`;
+    out[`--color-${tokens.softFg}`] = input;
+    out["--color-ring"] = input;
+  } else {
+    if (input.bg !== void 0) out[`--color-${tokens.main}`] = input.bg;
+    if (input.text !== void 0) out[`--color-${tokens.fg}`] = input.text;
+    if (input.soft !== void 0) out[`--color-${tokens.soft}`] = input.soft;
+    if (input.softText !== void 0) out[`--color-${tokens.softFg}`] = input.softText;
+    if (input.ring !== void 0) out["--color-ring"] = input.ring;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+const ColorExtensions = {
+  toneColorOverride,
+  TONE_TOKEN_MAP
+};
+function from(condition, value) {
+  return condition ? value : void 0;
+}
+const OptionalExtensions = {
+  from
+};
+const Environment = {
+  /** Refers to a local development build. */
+  Development: "development",
+  /** Refers to a production build. */
+  Production: "production",
+  /** Refers to a test build. */
+  Test: "test"
+};
+const IS_DEV = process.env.NODE_ENV !== "production";
+const IS_PRODUCTION = !IS_DEV;
+export {
+  ColorExtensions as C,
+  Environment as E,
+  IS_DEV as I,
+  OptionalExtensions as O,
+  ColorTone as a,
+  IS_PRODUCTION as b
+};
+//# sourceMappingURL=Environment-CuQav_mw.js.map

package/dist/chunks/Environment-CuQav_mw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Environment-CuQav_mw.js","sources":["../../src/foundation/utils/ColorExtensions/ColorExtensions.ts","../../src/foundation/utils/OptionalExtensions/OptionalExtensions.ts","../../src/foundation/utils/Environment/Environment.ts"],"sourcesContent":["import type { CSSProperties } from 'vue';\n\n/** Defines the tone vocabulary shared by tone-aware components (Button, Checkbox, ToggleButton, Tag, Alert, etc.). */\nexport const ColorTone = {\n  /** Refers to the primary brand palette. */\n  Primary: 'primary',\n  /** Refers to the neutral / default grey palette. */\n  Neutral: 'neutral',\n  /** Refers to the destructive / error palette. */\n  Danger: 'danger',\n  /** Refers to the positive / confirmation palette. */\n  Success: 'success',\n  /** Refers to the caution palette. */\n  Warning: 'warning',\n} as const;\n\nexport type ColorTone = (typeof ColorTone)[keyof typeof ColorTone];\n\n/* Explicit color overrides for the active tone's slot set. Pair with a base `tone` prop on the component. */\nexport interface ColorOverride {\n  /* Main background / fill color. Drives `bg-{tone}`, `hover:bg-{tone}/X`, `active:bg-{tone}/X`, `border-{tone}`, `ring-{tone}`. */\n  bg?: string;\n\n  /* Text/icon color on top of `bg`. Drives `text-{tone}-foreground`. */\n  text?: string;\n\n  /* Light tinted background for soft variants. Drives `bg-{tone}-soft`. */\n  soft?: string;\n\n  /* Text on top of `soft` background. Drives `text-{tone}-soft-foreground`. */\n  softText?: string;\n\n  /* Focus ring color override (else inherits the component's tone). */\n  ring?: string;\n}\n\n/* Accepted shapes for the `color` prop: a single seed string (lib derives rest) OR an explicit slot override object. */\nexport type ColorProp = string | ColorOverride;\n\n/* Per-tone CSS variable name suffixes (after `--color-`). */\nconst TONE_TOKEN_MAP: Record<\n  ColorTone,\n  { main: string; fg: string; soft: string; softFg: string }\n> = {\n  primary: { main: 'primary',     fg: 'primary-foreground',     soft: 'primary-soft',     softFg: 'primary-soft-foreground' },\n  neutral: { main: 'foreground',  fg: 'background',             soft: 'muted',            softFg: 'foreground' },\n  danger:  { main: 'destructive', fg: 'destructive-foreground', soft: 'destructive-soft', softFg: 'destructive-soft-foreground' },\n  success: { main: 'success',     fg: 'success-foreground',     soft: 'success-soft',     softFg: 'success-soft-foreground' },\n  warning: { main: 'warning',     fg: 'warning-foreground',     soft: 'warning-soft',     softFg: 'warning-soft-foreground' },\n};\n\n/**\n * Convert a `color` / `colors` prop into a CSS-variable override style for\n * the active tone's slot set. Returned style overrides the component's theme\n * tokens locally — every Tailwind utility (`bg-{tone}`, `hover:bg-{tone}/X`,\n * `text-{tone}-foreground`, etc.) that references the var picks it up\n * automatically. No variant config refactor required.\n *\n * Single-seed mode (`input` is a string):\n * - `bg` ← seed\n * - `text` ← white (default contrast; override via `colors.text`)\n * - `soft` ← seed mixed 12% over white via `color-mix(in oklch, ...)`\n * - `softText` ← seed\n * - `ring` ← seed\n *\n * Object mode (`input` is a `ColorOverride`):\n * - Each slot independently overridable; unset slots retain the theme default.\n */\nfunction toneColorOverride(\n  input: ColorProp | undefined,\n  tone: ColorTone | undefined,\n): CSSProperties | undefined {\n  if (input === undefined || input === null) return undefined;\n  const activeTone = tone ?? 'primary';\n  const tokens = TONE_TOKEN_MAP[activeTone];\n  const out: Record<string, string> = {};\n\n  if (typeof input === 'string') {\n    out[`--color-${tokens.main}`] = input;\n    out[`--color-${tokens.fg}`] = '#ffffff';\n    out[`--color-${tokens.soft}`] = `color-mix(in oklch, ${input} 12%, white)`;\n    out[`--color-${tokens.softFg}`] = input;\n    out['--color-ring'] = input;\n  } else {\n    if (input.bg !== undefined) out[`--color-${tokens.main}`] = input.bg;\n    if (input.text !== undefined) out[`--color-${tokens.fg}`] = input.text;\n    if (input.soft !== undefined) out[`--color-${tokens.soft}`] = input.soft;\n    if (input.softText !== undefined) out[`--color-${tokens.softFg}`] = input.softText;\n    if (input.ring !== undefined) out['--color-ring'] = input.ring;\n  }\n\n  return Object.keys(out).length > 0 ? (out as CSSProperties) : undefined;\n}\n\n// =============================================================================\n// Grouped namespace export\n// =============================================================================\n\nexport const ColorExtensions = {\n  toneColorOverride,\n  TONE_TOKEN_MAP,\n} as const;\n","/** Optional value extensions — call as `OptionalExtensions.x(...)`. */\n\n/**\n * Construct an optional from a `(condition, value)` pair: returns `value` when\n * `condition` is truthy, otherwise `undefined`. Use to keep DOM attributes\n * absent when their default/false meaning is what we want (e.g. `aria-busy`,\n * `tabIndex`, `disabled`).\n */\nfunction from<T>(condition: unknown, value: T): T | undefined {\n  return condition ? value : undefined;\n}\n\nexport const OptionalExtensions = {\n  from,\n} as const;\n","/** Defines the build environment. */\nexport const Environment = {\n  /** Refers to a local development build. */\n  Development: 'development',\n  /** Refers to a production build. */\n  Production: 'production',\n  /** Refers to a test build. */\n  Test: 'test',\n} as const;\n\nexport type Environment = (typeof Environment)[keyof typeof Environment];\n\n/* Gate dev-only warnings/affordances on these. The literal `'production'` is kept\n   inline so the consumer's bundler folds it and dev branches dead-code-eliminate. */\nexport const IS_DEV = process.env.NODE_ENV !== 'production';\nexport const IS_PRODUCTION = !IS_DEV;\n"],"names":[],"mappings":"AAGO,MAAM,YAAY;AAAA;AAAA,EAEvB,SAAS;AAAA;AAAA,EAET,SAAS;AAAA;AAAA,EAET,QAAQ;AAAA;AAAA,EAER,SAAS;AAAA;AAAA,EAET,SAAS;AACX;AA0BA,MAAM,iBAGF;AAAA,EACF,SAAS,EAAE,MAAM,WAAe,IAAI,sBAA0B,MAAM,gBAAoB,QAAQ,0BAAA;AAAA,EAChG,SAAS,EAAE,MAAM,cAAe,IAAI,cAA0B,MAAM,SAAoB,QAAQ,aAAA;AAAA,EAChG,QAAS,EAAE,MAAM,eAAe,IAAI,0BAA0B,MAAM,oBAAoB,QAAQ,8BAAA;AAAA,EAChG,SAAS,EAAE,MAAM,WAAe,IAAI,sBAA0B,MAAM,gBAAoB,QAAQ,0BAAA;AAAA,EAChG,SAAS,EAAE,MAAM,WAAe,IAAI,sBAA0B,MAAM,gBAAoB,QAAQ,0BAAA;AAClG;AAmBA,SAAS,kBACP,OACA,MAC2B;AAC3B,MAAI,UAAU,UAAa,UAAU,KAAM,QAAO;AAClD,QAAM,aAAa,QAAQ;AAC3B,QAAM,SAAS,eAAe,UAAU;AACxC,QAAM,MAA8B,CAAA;AAEpC,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,WAAW,OAAO,IAAI,EAAE,IAAI;AAChC,QAAI,WAAW,OAAO,EAAE,EAAE,IAAI;AAC9B,QAAI,WAAW,OAAO,IAAI,EAAE,IAAI,uBAAuB,KAAK;AAC5D,QAAI,WAAW,OAAO,MAAM,EAAE,IAAI;AAClC,QAAI,cAAc,IAAI;AAAA,EACxB,OAAO;AACL,QAAI,MAAM,OAAO,OAAW,KAAI,WAAW,OAAO,IAAI,EAAE,IAAI,MAAM;AAClE,QAAI,MAAM,SAAS,OAAW,KAAI,WAAW,OAAO,EAAE,EAAE,IAAI,MAAM;AAClE,QAAI,MAAM,SAAS,OAAW,KAAI,WAAW,OAAO,IAAI,EAAE,IAAI,MAAM;AACpE,QAAI,MAAM,aAAa,OAAW,KAAI,WAAW,OAAO,MAAM,EAAE,IAAI,MAAM;AAC1E,QAAI,MAAM,SAAS,OAAW,KAAI,cAAc,IAAI,MAAM;AAAA,EAC5D;AAEA,SAAO,OAAO,KAAK,GAAG,EAAE,SAAS,IAAK,MAAwB;AAChE;AAMO,MAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA;AACF;AC7FA,SAAS,KAAQ,WAAoB,OAAyB;AAC5D,SAAO,YAAY,QAAQ;AAC7B;AAEO,MAAM,qBAAqB;AAAA,EAChC;AACF;ACbO,MAAM,cAAc;AAAA;AAAA,EAEzB,aAAa;AAAA;AAAA,EAEb,YAAY;AAAA;AAAA,EAEZ,MAAM;AACR;AAMO,MAAM,SAAS,QAAQ,IAAI,aAAa;AACxC,MAAM,gBAAgB,CAAC;"}

package/dist/chunks/Equality-DIQYQysz.js

@@ -0,0 +1,21 @@
+const Equality = {
+  /** Checks NaN-safe strict equality (Object.is) — fits primitives + reference equality for objects. */
+  strictEquals: (a, b) => Object.is(a, b),
+  /** Checks plain `===` equality (NaN !== NaN). */
+  referenceEquals: (a, b) => a === b,
+  /** Provides a comparer that compares two objects by an extracted scalar key. */
+  byKey: (extract) => (a, b) => Object.is(extract(a), extract(b)),
+  /** Checks shallow object equality — equal iff every key has identical (Object.is) value. */
+  shallowEquals: (a, b) => {
+    if (Object.is(a, b)) return true;
+    if (a == null || b == null) return false;
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length) return false;
+    return ak.every((k) => Object.prototype.hasOwnProperty.call(b, k) && Object.is(a[k], b[k]));
+  }
+};
+export {
+  Equality as E
+};
+//# sourceMappingURL=Equality-DIQYQysz.js.map

package/dist/chunks/Equality-DIQYQysz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Equality-DIQYQysz.js","sources":["../../src/foundation/utils/Equality/Equality.ts"],"sourcesContent":["/* Provides reusable equality comparers for selection components and diff checks. */\n\n/** Represents a function that decides whether two values are equal. */\nexport type EqualityComparer<T> = (a: T, b: T) => boolean;\n\n/** Contains the standard equality comparers. */\nexport const Equality = {\n  /** Checks NaN-safe strict equality (Object.is) — fits primitives + reference equality for objects. */\n  strictEquals: <T>(a: T, b: T): boolean => Object.is(a, b),\n\n  /** Checks plain `===` equality (NaN !== NaN). */\n  referenceEquals: <T>(a: T, b: T): boolean => a === b,\n\n  /** Provides a comparer that compares two objects by an extracted scalar key. */\n  byKey:\n    <T, K = unknown>(extract: (item: T) => K): EqualityComparer<T> =>\n    (a, b) =>\n      Object.is(extract(a), extract(b)),\n\n  /** Checks shallow object equality — equal iff every key has identical (Object.is) value. */\n  shallowEquals: <T extends Record<string, unknown>>(a: T, b: T): boolean => {\n    if (Object.is(a, b)) return true;\n    if (a == null || b == null) return false;\n    const ak = Object.keys(a);\n    const bk = Object.keys(b);\n    if (ak.length !== bk.length) return false;\n    return ak.every((k) => Object.prototype.hasOwnProperty.call(b, k) && Object.is(a[k], b[k]));\n  },\n} as const;\n"],"names":[],"mappings":"AAMO,MAAM,WAAW;AAAA;AAAA,EAEtB,cAAc,CAAI,GAAM,MAAkB,OAAO,GAAG,GAAG,CAAC;AAAA;AAAA,EAGxD,iBAAiB,CAAI,GAAM,MAAkB,MAAM;AAAA;AAAA,EAGnD,OACE,CAAiB,YACjB,CAAC,GAAG,MACF,OAAO,GAAG,QAAQ,CAAC,GAAG,QAAQ,CAAC,CAAC;AAAA;AAAA,EAGpC,eAAe,CAAoC,GAAM,MAAkB;AACzE,QAAI,OAAO,GAAG,GAAG,CAAC,EAAG,QAAO;AAC5B,QAAI,KAAK,QAAQ,KAAK,KAAM,QAAO;AACnC,UAAM,KAAK,OAAO,KAAK,CAAC;AACxB,UAAM,KAAK,OAAO,KAAK,CAAC;AACxB,QAAI,GAAG,WAAW,GAAG,OAAQ,QAAO;AACpC,WAAO,GAAG,MAAM,CAAC,MAAM,OAAO,UAAU,eAAe,KAAK,GAAG,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;AAAA,EAC5F;AACF;"}

package/dist/chunks/ErrorLike-Cfj0lZW3.js

@@ -0,0 +1,27 @@
+function isObjectLike(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+}
+function readMember(source, key) {
+  try {
+    return source[key];
+  } catch {
+    return void 0;
+  }
+}
+function isError(value) {
+  try {
+    return value instanceof Error;
+  } catch {
+    return false;
+  }
+}
+function isErrorLike(value) {
+  return isObjectLike(value) && typeof readMember(value, "message") === "string";
+}
+export {
+  isError as a,
+  isObjectLike as b,
+  isErrorLike as i,
+  readMember as r
+};
+//# sourceMappingURL=ErrorLike-Cfj0lZW3.js.map

package/dist/chunks/ErrorLike-Cfj0lZW3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorLike-Cfj0lZW3.js","sources":["../../src/foundation/errors/ErrorLike.ts"],"sourcesContent":["/**\n * Defines the structural shape every helper in this slice accepts — anything carrying a string\n * `message`. Deliberately structural rather than `Error`: a value crossing a realm boundary\n * (iframe, worker, `structuredClone`), rehydrated from JSON, or built by a library that never\n * subclassed `Error` all fail `instanceof` while still being perfectly usable errors.\n */\nexport interface ErrorLike {\n  /** The human-readable failure description — the one member that makes a value error-like. */\n  readonly message: string;\n\n  /** The error kind — `'TypeError'`, `'AbortError'`, a custom tag. Absent on hand-rolled shapes. */\n  readonly name?: string;\n\n  /** The captured stack trace, when the source recorded one. */\n  readonly stack?: string;\n\n  /** The machine-readable code — Node's `'ETIMEDOUT'`, a legacy `DOMException` number, an app code. */\n  readonly code?: string | number;\n\n  /** The underlying failure this one wraps (the standard ES2022 `cause`). Untyped — anything can be thrown. */\n  readonly cause?: unknown;\n}\n\n/**\n * Checks whether a value can carry properties at all — `typeof null` is `'object'`, and a function\n * is a legal throw target. Internal; not barrelled.\n */\nexport function isObjectLike(value: unknown): value is object {\n  return value !== null && (typeof value === 'object' || typeof value === 'function');\n}\n\n/**\n * Reads a property without trusting the source. A getter can throw and a `Proxy` `get` trap can\n * throw, so an unguarded read would turn error handling into a second failure. Internal; not barrelled.\n */\nexport function readMember(source: object, key: string): unknown {\n  try {\n    return (source as Record<string, unknown>)[key];\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Checks `instanceof Error` without trusting the value — `instanceof` invokes `getPrototypeOf`,\n * which a `Proxy` trap can throw from. Internal; not barrelled.\n */\nexport function isError(value: unknown): value is Error {\n  try {\n    return value instanceof Error;\n  } catch {\n    return false;\n  }\n}\n\n/** Checks whether a value is structurally an {@link ErrorLike} — an object (or function) whose `message` reads as a string. */\nexport function isErrorLike(value: unknown): value is ErrorLike {\n  return isObjectLike(value) && typeof readMember(value, 'message') === 'string';\n}\n"],"names":[],"mappings":"AA2BO,SAAS,aAAa,OAAiC;AAC5D,SAAO,UAAU,SAAS,OAAO,UAAU,YAAY,OAAO,UAAU;AAC1E;AAMO,SAAS,WAAW,QAAgB,KAAsB;AAC/D,MAAI;AACF,WAAQ,OAAmC,GAAG;AAAA,EAChD,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAMO,SAAS,QAAQ,OAAgC;AACtD,MAAI;AACF,WAAO,iBAAiB;AAAA,EAC1B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAGO,SAAS,YAAY,OAAoC;AAC9D,SAAO,aAAa,KAAK,KAAK,OAAO,WAAW,OAAO,SAAS,MAAM;AACxE;"}

package/dist/chunks/ErrorMessage-Cqt7WaFn.js

@@ -0,0 +1,26 @@
+import { b as isObjectLike, r as readMember } from "./ErrorLike-Cfj0lZW3.js";
+const DefaultErrorMessage = "Something went wrong";
+function usableMessage(candidate) {
+  if (typeof candidate !== "string") return void 0;
+  const trimmed = candidate.trim();
+  if (trimmed === "" || trimmed === "[object Object]") return void 0;
+  return trimmed;
+}
+function getErrorMessage(value, fallback = DefaultErrorMessage) {
+  try {
+    const direct = usableMessage(value);
+    if (direct !== void 0) return direct;
+    if (isObjectLike(value)) {
+      const message = usableMessage(readMember(value, "message"));
+      if (message !== void 0) return message;
+    }
+    return usableMessage(fallback) ?? DefaultErrorMessage;
+  } catch {
+    return DefaultErrorMessage;
+  }
+}
+export {
+  DefaultErrorMessage as D,
+  getErrorMessage as g
+};
+//# sourceMappingURL=ErrorMessage-Cqt7WaFn.js.map

package/dist/chunks/ErrorMessage-Cqt7WaFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorMessage-Cqt7WaFn.js","sources":["../../src/foundation/errors/ErrorMessage.ts"],"sourcesContent":["import { isObjectLike, readMember } from './ErrorLike';\n\n/** Provides the message shown when a caught value carries nothing a person could read. Also the floor when a caller's own fallback is blank. */\nexport const DefaultErrorMessage = 'Something went wrong';\n\n/**\n * Accepts a candidate only if it is text worth showing — trimmed, non-blank, and not the\n * `'[object Object]'` tag an upstream `String(object)` may already have baked into a message.\n */\nfunction usableMessage(candidate: unknown): string | undefined {\n  if (typeof candidate !== 'string') return undefined;\n  const trimmed = candidate.trim();\n  if (trimmed === '' || trimmed === '[object Object]') return undefined;\n  return trimmed;\n}\n\n/**\n * Extracts the message a UI can show for a caught value — the string itself, or its `message` member.\n *\n * Narrower than `toError` on purpose. `toError` is total and must produce *some* `Error`, so it\n * stringifies whatever it gets; this returns UI copy, so a value with no message (a bare number, `{}`,\n * a JSON blob, `null`) yields `fallback` rather than rendering machine noise into a toast. Guaranteed\n * never to return `''` or `'[object Object]'` — a blank `fallback` degrades to {@link DefaultErrorMessage}.\n *\n * Never throws: a `message` getter that throws reads as absent.\n */\nexport function getErrorMessage(value: unknown, fallback: string = DefaultErrorMessage): string {\n  try {\n    const direct = usableMessage(value);\n    if (direct !== undefined) return direct;\n\n    if (isObjectLike(value)) {\n      const message = usableMessage(readMember(value, 'message'));\n      if (message !== undefined) return message;\n    }\n\n    return usableMessage(fallback) ?? DefaultErrorMessage;\n  } catch {\n    return DefaultErrorMessage;\n  }\n}\n"],"names":[],"mappings":";AAGO,MAAM,sBAAsB;AAMnC,SAAS,cAAc,WAAwC;AAC7D,MAAI,OAAO,cAAc,SAAU,QAAO;AAC1C,QAAM,UAAU,UAAU,KAAA;AAC1B,MAAI,YAAY,MAAM,YAAY,kBAAmB,QAAO;AAC5D,SAAO;AACT;AAYO,SAAS,gBAAgB,OAAgB,WAAmB,qBAA6B;AAC9F,MAAI;AACF,UAAM,SAAS,cAAc,KAAK;AAClC,QAAI,WAAW,OAAW,QAAO;AAEjC,QAAI,aAAa,KAAK,GAAG;AACvB,YAAM,UAAU,cAAc,WAAW,OAAO,SAAS,CAAC;AAC1D,UAAI,YAAY,OAAW,QAAO;AAAA,IACpC;AAEA,WAAO,cAAc,QAAQ,KAAK;AAAA,EACpC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;"}

package/dist/chunks/ErrorRecognizers-oTklha6D.js

@@ -0,0 +1,17 @@
+import { b as isObjectLike, r as readMember } from "./ErrorLike-Cfj0lZW3.js";
+function nameOf(value) {
+  if (!isObjectLike(value)) return void 0;
+  const name = readMember(value, "name");
+  return typeof name === "string" ? name : void 0;
+}
+function isAbortError(value) {
+  return nameOf(value) === "AbortError";
+}
+function isTimeoutError(value) {
+  return nameOf(value) === "TimeoutError";
+}
+export {
+  isTimeoutError as a,
+  isAbortError as i
+};
+//# sourceMappingURL=ErrorRecognizers-oTklha6D.js.map

package/dist/chunks/ErrorRecognizers-oTklha6D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorRecognizers-oTklha6D.js","sources":["../../src/foundation/errors/ErrorRecognizers.ts"],"sourcesContent":["import { isObjectLike, readMember } from './ErrorLike';\n\n/** Reads a value's `name` as a string — the single property both recognizers key off. Guarded, so a throwing getter reads as absent. */\nfunction nameOf(value: unknown): string | undefined {\n  if (!isObjectLike(value)) return undefined;\n  const name = readMember(value, 'name');\n  return typeof name === 'string' ? name : undefined;\n}\n\n/**\n * Checks whether a caught value is a cancellation — the `AbortError` every `fetch` / `AbortController`\n * path produces. The one recognizer every request layer needs: an abort means the caller moved on, so\n * it must be swallowed, never reported as a failure.\n *\n * Matched on `name`, deliberately not `instanceof DOMException`: the check has to hold for a\n * `DOMException` from another realm (iframe · worker), for environments with no `DOMException` global,\n * and for the plain `{ name: 'AbortError' }` that libraries and test doubles throw.\n */\nexport function isAbortError(value: unknown): boolean {\n  return nameOf(value) === 'AbortError';\n}\n\n/**\n * Checks whether a caught value is a timeout — `AbortSignal.timeout()` rejects with a `TimeoutError`\n * `DOMException`, and libraries copy that name.\n *\n * Name-only by design: no substring match on `message`. The word \"timeout\" appearing in prose is not a\n * contract, and matching it would misclassify unrelated failures (and break under translation).\n */\nexport function isTimeoutError(value: unknown): boolean {\n  return nameOf(value) === 'TimeoutError';\n}\n"],"names":[],"mappings":";AAGA,SAAS,OAAO,OAAoC;AAClD,MAAI,CAAC,aAAa,KAAK,EAAG,QAAO;AACjC,QAAM,OAAO,WAAW,OAAO,MAAM;AACrC,SAAO,OAAO,SAAS,WAAW,OAAO;AAC3C;AAWO,SAAS,aAAa,OAAyB;AACpD,SAAO,OAAO,KAAK,MAAM;AAC3B;AASO,SAAS,eAAe,OAAyB;AACtD,SAAO,OAAO,KAAK,MAAM;AAC3B;"}

package/dist/chunks/FeedbackBus-BRbyOMCn.js

@@ -0,0 +1,39 @@
+import { S as Severity } from "./Severity-D0C5oAt-.js";
+const NoticeTone = {
+  /** Refers to an informational notice. */
+  Info: Severity.Info,
+  /** Refers to a positive / success notice. */
+  Success: Severity.Success,
+  /** Refers to a caution / warning notice. */
+  Warning: Severity.Warning,
+  /** Refers to a destructive / error notice. */
+  Danger: Severity.Danger
+};
+function createFeedbackBus() {
+  const listeners = /* @__PURE__ */ new Set();
+  let idSeq = 0;
+  return {
+    notify(notice) {
+      const published = { ...notice, id: notice.id ?? `n_${++idSeq}` };
+      for (const listener of [...listeners]) listener(published);
+      return published.id;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+const feedbackBus = createFeedbackBus();
+function notify(notice) {
+  return feedbackBus.notify(notice);
+}
+export {
+  NoticeTone as N,
+  createFeedbackBus as c,
+  feedbackBus as f,
+  notify as n
+};
+//# sourceMappingURL=FeedbackBus-BRbyOMCn.js.map

package/dist/chunks/FeedbackBus-BRbyOMCn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedbackBus-BRbyOMCn.js","sources":["../../src/feedback/FeedbackBus.ts"],"sourcesContent":["import type { VNode } from 'vue';\n\nimport { Severity } from '../foundation/utils';\n\n/** Defines the tone of a notice — the house `Severity` vocabulary minus `neutral` (a notice always carries intent). */\nexport const NoticeTone = {\n  /** Refers to an informational notice. */\n  Info: Severity.Info,\n  /** Refers to a positive / success notice. */\n  Success: Severity.Success,\n  /** Refers to a caution / warning notice. */\n  Warning: Severity.Warning,\n  /** Refers to a destructive / error notice. */\n  Danger: Severity.Danger,\n} as const;\n\nexport type NoticeTone = (typeof NoticeTone)[keyof typeof NoticeTone];\n\n/**\n * A renderable slice of a notice. React's `ReactNode` becomes `string | VNode`\n * for the same reason the `Toaster` payload did: notices travel as data through\n * `notify()`, not through a slot, so a caller who wants markup builds it with\n * `h()`. Structurally identical to `presentation/feedback`'s `ToastNode` — the\n * adapter's assignment is what keeps the two from drifting, and this module\n * cannot import that one (boundaries: `feedback` never reaches into\n * `presentation`).\n */\nexport type NoticeNode = string | VNode;\n\n/** Defines a feedback notice published on the bus — the headless payload a presentation adapter renders (toast, banner, notification center…). */\nexport interface FeedbackNotice {\n  /** The semantic tone — maps 1:1 onto the toast `severity` vocabulary. */\n  readonly tone: NoticeTone;\n\n  /** The headline. */\n  readonly title: NoticeNode;\n\n  /** The optional supporting body. */\n  readonly description?: NoticeNode;\n\n  /** An optional action slot (e.g. a retry button) — passed through to the rendering surface. */\n  readonly action?: NoticeNode;\n\n  /** An optional stable identity — assigned by the bus (`n_<seq>`) when omitted; callers set it for future dedupe / notification-center use. */\n  readonly id?: string;\n\n  /** ms before the rendering surface auto-dismisses. Surface default when omitted; `Infinity` = sticky. */\n  readonly durationMs?: number;\n}\n\n/** Defines a notice as delivered to subscribers — identity always assigned. */\nexport interface PublishedNotice extends FeedbackNotice {\n  readonly id: string;\n}\n\n/** Defines a listener notified on every published notice. */\nexport type NoticeListener = (notice: PublishedNotice) => void;\n\n/**\n * Defines the module-scope feedback hub wiring app code to whatever surface renders notices.\n * Fire-and-forget pub/sub (no replay): a notice published with no subscriber is dropped, so mount\n * the adapter (`<FeedbackToasts/>`) before publishing. Nothing subscribes automatically — GWDNBM,\n * every wire is explicit:\n *\n * - **Notices in** — `notify({ tone, title })` from anywhere (composables, api client code, stores);\n *   `feedbackQueryErrors(bus)` plugs a `/query` global error seam in.\n * - **Toasts out** — `<FeedbackToasts/>` (`/presentation/feedback`) subscribes and forwards each\n *   notice into the imperative `toaster.toast()` API.\n *\n * Plain module state rather than a Vue plugin / `provide`: the bus is publisher-agnostic, and a\n * publisher is rarely inside a component's `setup()` (an interceptor, a store action). The\n * `bus` prop on the adapter is the isolation seam an app needs instead.\n */\nexport interface FeedbackBus {\n  /** Publishes a notice to all subscribers — safe to call with none mounted (no-op); returns the notice id. */\n  notify(notice: FeedbackNotice): string;\n\n  /** Subscribes to published notices; returns an unsubscribe. */\n  subscribe(listener: NoticeListener): () => void;\n}\n\n/** Creates a {@link FeedbackBus} — one per app, module scope, shared by publishers and the rendering adapter. Apps that don't need isolation use the default {@link feedbackBus}. */\nexport function createFeedbackBus(): FeedbackBus {\n  const listeners = new Set<NoticeListener>();\n  let idSeq = 0;\n\n  return {\n    notify(notice: FeedbackNotice): string {\n      const published: PublishedNotice = { ...notice, id: notice.id ?? `n_${++idSeq}` };\n      for (const listener of [...listeners]) listener(published);\n      return published.id;\n    },\n\n    subscribe(listener: NoticeListener): () => void {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n  };\n}\n\n/** The default app-wide bus — what `notify` and the adapters bind to unless handed an explicit bus. */\nexport const feedbackBus: FeedbackBus = createFeedbackBus();\n\n/** Publishes a notice on the default {@link feedbackBus} — the everyday `notify({ tone: 'success', title: 'Saved' })` entry point. */\nexport function notify(notice: FeedbackNotice): string {\n  return feedbackBus.notify(notice);\n}\n"],"names":[],"mappings":";AAKO,MAAM,aAAa;AAAA;AAAA,EAExB,MAAM,SAAS;AAAA;AAAA,EAEf,SAAS,SAAS;AAAA;AAAA,EAElB,SAAS,SAAS;AAAA;AAAA,EAElB,QAAQ,SAAS;AACnB;AAoEO,SAAS,oBAAiC;AAC/C,QAAM,gCAAgB,IAAA;AACtB,MAAI,QAAQ;AAEZ,SAAO;AAAA,IACL,OAAO,QAAgC;AACrC,YAAM,YAA6B,EAAE,GAAG,QAAQ,IAAI,OAAO,MAAM,KAAK,EAAE,KAAK,GAAA;AAC7E,iBAAW,YAAY,CAAC,GAAG,SAAS,YAAY,SAAS;AACzD,aAAO,UAAU;AAAA,IACnB;AAAA,IAEA,UAAU,UAAsC;AAC9C,gBAAU,IAAI,QAAQ;AACtB,aAAO,MAAM;AACX,kBAAU,OAAO,QAAQ;AAAA,MAC3B;AAAA,IACF;AAAA,EAAA;AAEJ;AAGO,MAAM,cAA2B,kBAAA;AAGjC,SAAS,OAAO,QAAgC;AACrD,SAAO,YAAY,OAAO,MAAM;AAClC;"}

package/dist/chunks/FieldErrors-2zjhia4U.js

@@ -0,0 +1,56 @@
+import { F as FLUENT_VALIDATION_PARAMS, a as FLUENT_VALIDATION_CODES } from "./Messages-BGfQHMmW.js";
+import { A as ApiError } from "./ApiError-l0YdcqqV.js";
+function normalizeCode(code) {
+  if (typeof code !== "string" || code.length === 0) return void 0;
+  return FLUENT_VALIDATION_CODES[code] ?? code;
+}
+function normalizeParams(params) {
+  if (params === null || typeof params !== "object" || Array.isArray(params)) return void 0;
+  const normalized = {};
+  let count = 0;
+  for (const [key, value] of Object.entries(params)) {
+    normalized[FLUENT_VALIDATION_PARAMS[key] ?? key] = value;
+    count += 1;
+  }
+  return count > 0 ? normalized : void 0;
+}
+function fieldIssues(error) {
+  if (!(error instanceof ApiError)) return {};
+  const errors = error.problem?.errors;
+  if (Array.isArray(errors)) {
+    const map = {};
+    for (const entry of errors) {
+      if (entry === null || typeof entry !== "object") continue;
+      const { property, message, code, params } = entry;
+      if (typeof property !== "string" || typeof message !== "string") continue;
+      (map[property] ??= []).push({
+        message,
+        code: normalizeCode(code),
+        params: normalizeParams(params)
+      });
+    }
+    return map;
+  }
+  if (errors !== null && typeof errors === "object") {
+    const map = {};
+    for (const [field, value] of Object.entries(errors)) {
+      const issues = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string").map((message) => ({ message }));
+      if (issues.length > 0) map[field] = issues;
+    }
+    return map;
+  }
+  return {};
+}
+function fieldErrors(error) {
+  const issues = fieldIssues(error);
+  const map = {};
+  for (const [field, entries] of Object.entries(issues)) {
+    map[field] = entries.map((issue) => issue.message);
+  }
+  return map;
+}
+export {
+  fieldErrors as a,
+  fieldIssues as f
+};
+//# sourceMappingURL=FieldErrors-2zjhia4U.js.map

package/dist/chunks/FieldErrors-2zjhia4U.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldErrors-2zjhia4U.js","sources":["../../src/foundation/http/FieldErrors.ts"],"sourcesContent":["import {\n  FLUENT_VALIDATION_CODES,\n  FLUENT_VALIDATION_PARAMS,\n  type FieldIssue,\n} from '../validation/Messages';\n\nimport { ApiError } from './ApiError';\n\n/*\n * Reads the per-field validation failures out of a thrown error's problem body.\n *\n * TWO READERS, ONE PARSE. `fieldIssues` is the wide one — it keeps each failure's rule code and\n * operands, which is what a message catalogue keys on (`foundation/validation/Messages.ts`).\n * `fieldErrors` is the narrow one, kept for the `Record<string, string[]>` shape the forms engine has\n * always exposed; it delegates and drops everything but the message.\n *\n * WHY THE CODE WAS WORTH RESCUING: the wow-two backend already puts it on the wire —\n * `{\"errors\":[{\"property\":\"Rules[0].Content.Url\",\"message\":\"URL is required.\",\"code\":\"NotEmptyValidator\"}]}`\n * — and every client discarded it right here, which is why the client and the server could never agree\n * on the wording of a rule they both enforce.\n *\n * NORMALIZATION HAPPENS ON THIS SIDE ON PURPOSE. FluentValidation's `ErrorCode` vocabulary\n * (`NotEmptyValidator`) is not the vocabulary the client's own validators report (`required`), and one\n * catalogue cannot serve two. Translating here — rather than waiting for the server to emit the shared\n * codes — lets a form adopt the catalogue today and keeps working unchanged once the backend normalizes\n * too, since an already-shared code passes through the alias table untouched.\n */\n\n/** Normalizes a source rule code onto the shared vocabulary, passing an unknown code through unchanged. */\nfunction normalizeCode(code: unknown): string | undefined {\n  if (typeof code !== 'string' || code.length === 0) return undefined;\n  return FLUENT_VALIDATION_CODES[code] ?? code;\n}\n\n/** Renames a payload's operand keys onto the vocabulary's (`MaxLength` → `max`), keeping unlisted ones. */\nfunction normalizeParams(params: unknown): Readonly<Record<string, unknown>> | undefined {\n  if (params === null || typeof params !== 'object' || Array.isArray(params)) return undefined;\n  const normalized: Record<string, unknown> = {};\n  let count = 0;\n  for (const [key, value] of Object.entries(params as Record<string, unknown>)) {\n    normalized[FLUENT_VALIDATION_PARAMS[key] ?? key] = value;\n    count += 1;\n  }\n  return count > 0 ? normalized : undefined;\n}\n\n/**\n * Extracts the per-field validation failures from a thrown error — the `errors` member of an\n * {@link ApiError}'s problem body, normalized to `field → issues` with each rule code and its operands\n * preserved. Handles both the ASP.NET ValidationProblemDetails / ModelState dict (`{ field: string[] }`,\n * a bare string value counts as one message — that shape carries no code) and the wow-two backend's\n * array shape (`[{ property, message, code?, params? }]`, grouped by property). Anything else —\n * non-`ApiError`, no problem body, no `errors` member — yields `{}` so callers can map unconditionally.\n */\nexport function fieldIssues(error: unknown): Record<string, FieldIssue[]> {\n  if (!(error instanceof ApiError)) return {};\n  const errors = error.problem?.errors;\n\n  if (Array.isArray(errors)) {\n    const map: Record<string, FieldIssue[]> = {};\n    for (const entry of errors as unknown[]) {\n      if (entry === null || typeof entry !== 'object') continue;\n      const { property, message, code, params } = entry as {\n        property?: unknown;\n        message?: unknown;\n        code?: unknown;\n        params?: unknown;\n      };\n      if (typeof property !== 'string' || typeof message !== 'string') continue;\n      (map[property] ??= []).push({\n        message,\n        code: normalizeCode(code),\n        params: normalizeParams(params),\n      });\n    }\n    return map;\n  }\n\n  if (errors !== null && typeof errors === 'object') {\n    const map: Record<string, FieldIssue[]> = {};\n    for (const [field, value] of Object.entries(errors)) {\n      // The ModelState shape carries messages only — no code, so these never reach a catalogue entry\n      // and render exactly as the server wrote them.\n      const issues = (Array.isArray(value) ? value : [value])\n        .filter((item): item is string => typeof item === 'string')\n        .map((message) => ({ message }));\n      if (issues.length > 0) map[field] = issues;\n    }\n    return map;\n  }\n\n  return {};\n}\n\n/**\n * Extracts the per-field validation messages from a thrown error, normalized to `field → messages` for\n * mapping onto form fields. The message-only view of {@link fieldIssues} — reach for that one when the\n * rule code matters (message catalogue, per-code UI); this stays the shape every existing caller expects.\n */\nexport function fieldErrors(error: unknown): Record<string, string[]> {\n  const issues = fieldIssues(error);\n  const map: Record<string, string[]> = {};\n  for (const [field, entries] of Object.entries(issues)) {\n    map[field] = entries.map((issue) => issue.message);\n  }\n  return map;\n}\n"],"names":[],"mappings":";;AA6BA,SAAS,cAAc,MAAmC;AACxD,MAAI,OAAO,SAAS,YAAY,KAAK,WAAW,EAAG,QAAO;AAC1D,SAAO,wBAAwB,IAAI,KAAK;AAC1C;AAGA,SAAS,gBAAgB,QAAgE;AACvF,MAAI,WAAW,QAAQ,OAAO,WAAW,YAAY,MAAM,QAAQ,MAAM,EAAG,QAAO;AACnF,QAAM,aAAsC,CAAA;AAC5C,MAAI,QAAQ;AACZ,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAiC,GAAG;AAC5E,eAAW,yBAAyB,GAAG,KAAK,GAAG,IAAI;AACnD,aAAS;AAAA,EACX;AACA,SAAO,QAAQ,IAAI,aAAa;AAClC;AAUO,SAAS,YAAY,OAA8C;AACxE,MAAI,EAAE,iBAAiB,UAAW,QAAO,CAAA;AACzC,QAAM,SAAS,MAAM,SAAS;AAE9B,MAAI,MAAM,QAAQ,MAAM,GAAG;AACzB,UAAM,MAAoC,CAAA;AAC1C,eAAW,SAAS,QAAqB;AACvC,UAAI,UAAU,QAAQ,OAAO,UAAU,SAAU;AACjD,YAAM,EAAE,UAAU,SAAS,MAAM,WAAW;AAM5C,UAAI,OAAO,aAAa,YAAY,OAAO,YAAY,SAAU;AACjE,OAAC,IAAI,QAAQ,MAAM,CAAA,GAAI,KAAK;AAAA,QAC1B;AAAA,QACA,MAAM,cAAc,IAAI;AAAA,QACxB,QAAQ,gBAAgB,MAAM;AAAA,MAAA,CAC/B;AAAA,IACH;AACA,WAAO;AAAA,EACT;AAEA,MAAI,WAAW,QAAQ,OAAO,WAAW,UAAU;AACjD,UAAM,MAAoC,CAAA;AAC1C,eAAW,CAAC,OAAO,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AAGnD,YAAM,UAAU,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK,GAClD,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ,EACzD,IAAI,CAAC,aAAa,EAAE,QAAA,EAAU;AACjC,UAAI,OAAO,SAAS,EAAG,KAAI,KAAK,IAAI;AAAA,IACtC;AACA,WAAO;AAAA,EACT;AAEA,SAAO,CAAA;AACT;AAOO,SAAS,YAAY,OAA0C;AACpE,QAAM,SAAS,YAAY,KAAK;AAChC,QAAM,MAAgC,CAAA;AACtC,aAAW,CAAC,OAAO,OAAO,KAAK,OAAO,QAAQ,MAAM,GAAG;AACrD,QAAI,KAAK,IAAI,QAAQ,IAAI,CAAC,UAAU,MAAM,OAAO;AAAA,EACnD;AACA,SAAO;AACT;"}

package/dist/chunks/FileName-CmNjFV7t.js

@@ -0,0 +1,30 @@
+function fileExtension(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot <= 0 || lastDot === filename.length - 1) return "";
+  return filename.slice(lastDot + 1).toLowerCase();
+}
+function fileBaseName(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot <= 0 || lastDot === filename.length - 1) return filename;
+  return filename.slice(0, lastDot);
+}
+const CONTROL_CHARS = new RegExp("[\\u0000-\\u001f\\u007f]", "g");
+const RESERVED_CHARS = /[/\\<>:"|?*]+/g;
+function safeFileName(name, options) {
+  const replacement = options?.replacement ?? "-";
+  const maxLength = Math.max(1, options?.maxLength ?? 255);
+  const cleaned = name.replace(CONTROL_CHARS, "").replace(RESERVED_CHARS, replacement).replace(/\s+/g, " ").replace(/^[.\s]+|[.\s]+$/g, "").trim();
+  if (cleaned === "") return "file";
+  if (cleaned.length <= maxLength) return cleaned;
+  const extension = fileExtension(cleaned);
+  if (extension === "") return cleaned.slice(0, maxLength);
+  const suffix = `.${extension}`;
+  const headLength = Math.max(1, maxLength - suffix.length);
+  return fileBaseName(cleaned).slice(0, headLength) + suffix;
+}
+export {
+  fileExtension as a,
+  fileBaseName as f,
+  safeFileName as s
+};
+//# sourceMappingURL=FileName-CmNjFV7t.js.map

package/dist/chunks/FileName-CmNjFV7t.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileName-CmNjFV7t.js","sources":["../../src/foundation/files/FileName.ts"],"sourcesContent":["// File-name parsing — extension and base-name extraction, plus safe-name sanitizing for a download. Pure string\n// work, deliberately separate from the DOM helpers so it stays node-testable.\n\n/**\n * Returns the lower-cased extension of a file name, without the leading dot. Yields `''` when there is no\n * extension, when the name is a dotfile (`.gitignore` — the dot starts the name, it doesn't separate one), or\n * when the dot is trailing.\n */\nexport function fileExtension(filename: string): string {\n  const lastDot = filename.lastIndexOf('.');\n  if (lastDot <= 0 || lastDot === filename.length - 1) return '';\n  return filename.slice(lastDot + 1).toLowerCase();\n}\n\n/** Returns the file name without its extension (`report.final.pdf` → `report.final`). Dotfiles are returned whole. */\nexport function fileBaseName(filename: string): string {\n  const lastDot = filename.lastIndexOf('.');\n  if (lastDot <= 0 || lastDot === filename.length - 1) return filename;\n  return filename.slice(0, lastDot);\n}\n\n/** Tunes download-name sanitizing. */\nexport interface SafeFileNameOptions {\n  /** The character replacing each illegal run. Defaults to `-`. */\n  readonly replacement?: string;\n\n  /** Maximum length of the result (extension preserved when truncating). Defaults to `255`. */\n  readonly maxLength?: number;\n}\n\n/**\n * Control characters (C0 range plus DEL) — built from escape sequences rather than a regex literal so no literal\n * control byte ever appears in this source file.\n */\n// eslint-disable-next-line no-control-regex -- stripping control chars is the point of this pattern\nconst CONTROL_CHARS = new RegExp('[\\\\u0000-\\\\u001f\\\\u007f]', 'g');\n\n/** Path separators + the characters Windows reserves in a file name. */\nconst RESERVED_CHARS = /[/\\\\<>:\"|?*]+/g;\n\n/**\n * Sanitizes a string into a file name safe across Windows / macOS / Linux: strips path separators, the reserved\n * characters `< > : \" | ? *`, and control characters; collapses whitespace; trims leading/trailing dots and\n * spaces. Truncates to `maxLength` while preserving the extension. Returns `'file'` when nothing usable remains.\n */\nexport function safeFileName(name: string, options?: SafeFileNameOptions): string {\n  const replacement = options?.replacement ?? '-';\n  const maxLength = Math.max(1, options?.maxLength ?? 255);\n\n  const cleaned = name\n    .replace(CONTROL_CHARS, '')\n    .replace(RESERVED_CHARS, replacement)\n    .replace(/\\s+/g, ' ')\n    .replace(/^[.\\s]+|[.\\s]+$/g, '')\n    .trim();\n\n  if (cleaned === '') return 'file';\n  if (cleaned.length <= maxLength) return cleaned;\n\n  // Truncate the base, keep the extension so the file still opens with the right handler.\n  const extension = fileExtension(cleaned);\n  if (extension === '') return cleaned.slice(0, maxLength);\n\n  const suffix = `.${extension}`;\n  const headLength = Math.max(1, maxLength - suffix.length);\n  return fileBaseName(cleaned).slice(0, headLength) + suffix;\n}\n"],"names":[],"mappings":"AAQO,SAAS,cAAc,UAA0B;AACtD,QAAM,UAAU,SAAS,YAAY,GAAG;AACxC,MAAI,WAAW,KAAK,YAAY,SAAS,SAAS,EAAG,QAAO;AAC5D,SAAO,SAAS,MAAM,UAAU,CAAC,EAAE,YAAA;AACrC;AAGO,SAAS,aAAa,UAA0B;AACrD,QAAM,UAAU,SAAS,YAAY,GAAG;AACxC,MAAI,WAAW,KAAK,YAAY,SAAS,SAAS,EAAG,QAAO;AAC5D,SAAO,SAAS,MAAM,GAAG,OAAO;AAClC;AAgBA,MAAM,gBAAgB,IAAI,OAAO,4BAA4B,GAAG;AAGhE,MAAM,iBAAiB;AAOhB,SAAS,aAAa,MAAc,SAAuC;AAChF,QAAM,cAAc,SAAS,eAAe;AAC5C,QAAM,YAAY,KAAK,IAAI,GAAG,SAAS,aAAa,GAAG;AAEvD,QAAM,UAAU,KACb,QAAQ,eAAe,EAAE,EACzB,QAAQ,gBAAgB,WAAW,EACnC,QAAQ,QAAQ,GAAG,EACnB,QAAQ,oBAAoB,EAAE,EAC9B,KAAA;AAEH,MAAI,YAAY,GAAI,QAAO;AAC3B,MAAI,QAAQ,UAAU,UAAW,QAAO;AAGxC,QAAM,YAAY,cAAc,OAAO;AACvC,MAAI,cAAc,GAAI,QAAO,QAAQ,MAAM,GAAG,SAAS;AAEvD,QAAM,SAAS,IAAI,SAAS;AAC5B,QAAM,aAAa,KAAK,IAAI,GAAG,YAAY,OAAO,MAAM;AACxD,SAAO,aAAa,OAAO,EAAE,MAAM,GAAG,UAAU,IAAI;AACtD;"}

package/dist/chunks/FormControlContext-B71MFW26.js

@@ -0,0 +1,22 @@
+import { inject, watch, toValue } from "vue";
+const FormControlKey = Symbol("wow-two.formControl");
+function useFormControl() {
+  return inject(FormControlKey, null);
+}
+function useFormControlChrome(kind, isRendered) {
+  const context = useFormControl();
+  watch(
+    () => toValue(isRendered),
+    (isRenderedNow, _previous, onCleanup) => {
+      if (!isRenderedNow || !context) return;
+      onCleanup(context.registerChrome(kind));
+    },
+    { immediate: true, flush: "post" }
+  );
+}
+export {
+  FormControlKey as F,
+  useFormControlChrome as a,
+  useFormControl as u
+};
+//# sourceMappingURL=FormControlContext-B71MFW26.js.map

package/dist/chunks/FormControlContext-B71MFW26.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormControlContext-B71MFW26.js","sources":["../../src/foundation/primitives/formControlContext/FormControlContext.ts"],"sourcesContent":["import { inject, toValue, watch, type InjectionKey, type MaybeRefOrGetter } from 'vue';\n\n/** The chrome slots a form control can be described/named by. */\nexport type FormControlChromeKind = 'label' | 'helper' | 'error';\n\nexport interface FormControlContextValue {\n  readonly id: string;\n  readonly labelId: string;\n  readonly helperId: string;\n  readonly errorId: string;\n  /**\n   * The `aria-labelledby` target — `labelId` only while a Label chrome is actually\n   * mounted, else `undefined`. Widgets that can't be named via `for` (button\n   * triggers, ARIA sliders) reference THIS, never `labelId` directly — referencing\n   * a non-rendered id is an axe `aria-valid-attr-value` violation.\n   */\n  readonly labelledBy?: string;\n  /**\n   * The `aria-describedby` target — only the ids of helper/error chrome actually\n   * mounted (space-joined), else `undefined`. Controls wire this verbatim; never\n   * hand-compose `helperId`/`errorId` (dangling ids when the chrome isn't rendered).\n   */\n  readonly describedBy?: string;\n  /**\n   * The field's error messages (client + server merged, client first) — fed by the\n   * forms-engine `Field` glue so error chrome (`FormErrorMessage`) renders them\n   * without hand-wiring. `undefined` outside an engine-driven field.\n   */\n  readonly errors?: readonly string[];\n  readonly isInvalid: boolean;\n  readonly isDisabled: boolean;\n  readonly isRequired: boolean;\n  readonly isReadOnly: boolean;\n  /** Registers a mounted chrome node (label/helper/error); returns the unregister. Chrome uses {@link useFormControlChrome}. */\n  registerChrome: (kind: FormControlChromeKind) => () => void;\n}\n\nexport const FormControlKey: InjectionKey<FormControlContextValue> = Symbol('wow-two.formControl');\n\n/**\n * Read the surrounding form-control context. Returns `null` when used\n * outside a provider — atoms gracefully degrade to standalone mode.\n *\n * Every field on the returned object is a live getter, so `ctx.describedBy`\n * re-reads on each access. Destructuring takes a one-time snapshot; bind to\n * the object instead.\n */\nexport function useFormControl(): FormControlContextValue | null {\n  return inject(FormControlKey, null);\n}\n\n/**\n * Registers a chrome node (label/helper/error) with the surrounding form control\n * while `isRendered` — flips the context's `labelledBy`/`describedBy` to include\n * the node's id only for the frames it actually exists. Call unconditionally;\n * pass `isRendered: false` when the chrome renders nothing or renders under an\n * explicit `id` prop instead of the context id.\n *\n * `isRendered` accepts a ref or getter as well as a plain boolean — the React\n * version re-ran its effect on every render, where Vue needs the reactive source\n * named. `flush: 'post'` is the `useLayoutEffect` equivalent: the registration\n * lands after the DOM updates, before paint.\n */\nexport function useFormControlChrome(\n  kind: FormControlChromeKind,\n  isRendered: MaybeRefOrGetter<boolean>,\n): void {\n  const context = useFormControl();\n  watch(\n    () => toValue(isRendered),\n    (isRenderedNow, _previous, onCleanup) => {\n      if (!isRenderedNow || !context) return;\n      onCleanup(context.registerChrome(kind));\n    },\n    { immediate: true, flush: 'post' },\n  );\n}\n"],"names":[],"mappings":";AAqCO,MAAM,iBAAwD,OAAO,qBAAqB;AAU1F,SAAS,iBAAiD;AAC/D,SAAO,OAAO,gBAAgB,IAAI;AACpC;AAcO,SAAS,qBACd,MACA,YACM;AACN,QAAM,UAAU,eAAA;AAChB;AAAA,IACE,MAAM,QAAQ,UAAU;AAAA,IACxB,CAAC,eAAe,WAAW,cAAc;AACvC,UAAI,CAAC,iBAAiB,CAAC,QAAS;AAChC,gBAAU,QAAQ,eAAe,IAAI,CAAC;AAAA,IACxC;AAAA,IACA,EAAE,WAAW,MAAM,OAAO,OAAA;AAAA,EAAO;AAErC;"}

package/dist/chunks/FormControlProvider.vue_vue_type_script_setup_true_lang-Fak7Jv46.js

@@ -0,0 +1,73 @@
+import { defineComponent, useId, shallowRef, provide, renderSlot } from "vue";
+import { F as FormControlKey } from "./FormControlContext-B71MFW26.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "FormControlProvider" },
+  __name: "FormControlProvider",
+  props: {
+    id: {},
+    errors: {},
+    isInvalid: { type: Boolean, default: false },
+    isDisabled: { type: Boolean, default: false },
+    isRequired: { type: Boolean, default: false },
+    isReadOnly: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const generatedId = useId();
+    const chrome = shallowRef({ label: 0, helper: 0, error: 0 });
+    function registerChrome(kind) {
+      chrome.value = { ...chrome.value, [kind]: chrome.value[kind] + 1 };
+      return () => {
+        chrome.value = { ...chrome.value, [kind]: chrome.value[kind] - 1 };
+      };
+    }
+    const id = () => props.id ?? generatedId;
+    const context = {
+      get id() {
+        return id();
+      },
+      get labelId() {
+        return `${id()}-label`;
+      },
+      get helperId() {
+        return `${id()}-helper`;
+      },
+      get errorId() {
+        return `${id()}-error`;
+      },
+      get labelledBy() {
+        return chrome.value.label > 0 ? `${id()}-label` : void 0;
+      },
+      get describedBy() {
+        return [
+          chrome.value.helper > 0 && `${id()}-helper`,
+          chrome.value.error > 0 && `${id()}-error`
+        ].filter(Boolean).join(" ") || void 0;
+      },
+      get errors() {
+        return props.errors;
+      },
+      get isInvalid() {
+        return props.isInvalid;
+      },
+      get isDisabled() {
+        return props.isDisabled;
+      },
+      get isRequired() {
+        return props.isRequired;
+      },
+      get isReadOnly() {
+        return props.isReadOnly;
+      },
+      registerChrome
+    };
+    provide(FormControlKey, context);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  _sfc_main as _
+};
+//# sourceMappingURL=FormControlProvider.vue_vue_type_script_setup_true_lang-Fak7Jv46.js.map

package/dist/chunks/FormControlProvider.vue_vue_type_script_setup_true_lang-Fak7Jv46.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormControlProvider.vue_vue_type_script_setup_true_lang-Fak7Jv46.js","sources":["../../src/foundation/primitives/formControlContext/FormControlProvider.vue"],"sourcesContent":["<script lang=\"ts\">\nexport interface FormControlProviderProps {\n  /** The id override for the auto-generated id (also used as control's `id`). */\n  id?: string;\n  /** The field's error messages — exposed to chrome via context. */\n  errors?: readonly string[];\n  isInvalid?: boolean;\n  isDisabled?: boolean;\n  isRequired?: boolean;\n  isReadOnly?: boolean;\n}\n\ntype ChromeCounts = Record<'label' | 'helper' | 'error', number>;\n</script>\n\n<script setup lang=\"ts\">\nimport { provide, shallowRef, useId } from 'vue';\nimport {\n  FormControlKey,\n  type FormControlChromeKind,\n  type FormControlContextValue,\n} from './FormControlContext';\n\n/**\n * Wires Label ↔ control ↔ HelperText/ErrorMessage via stable IDs and shared\n * state flags. Used by `Field` (L4) and the forms-engine `Field` glue — atoms\n * (Input, Label, etc.) read via `useFormControl()` to get the right\n * `id`/`for`/`aria-describedby`. Chrome nodes self-register on mount, so\n * `labelledBy`/`describedBy` only ever reference ids that exist in the DOM.\n */\ndefineOptions({ name: 'FormControlProvider' });\n\nconst props = withDefaults(defineProps<FormControlProviderProps>(), {\n  isInvalid: false,\n  isDisabled: false,\n  isRequired: false,\n  isReadOnly: false,\n});\n\n// Vue 3.5's own `useId` — SSR-stable and hydration-safe, the same guarantee\n// React's `useId` gave. The React package wrapped it in `hooks/useId` only to\n// add a debug prefix.\nconst generatedId = useId();\n\nconst chrome = shallowRef<ChromeCounts>({ label: 0, helper: 0, error: 0 });\n\nfunction registerChrome(kind: FormControlChromeKind): () => void {\n  chrome.value = { ...chrome.value, [kind]: chrome.value[kind] + 1 };\n  return () => {\n    chrome.value = { ...chrome.value, [kind]: chrome.value[kind] - 1 };\n  };\n}\n\nconst id = (): string => props.id ?? generatedId;\n\n// Getters, so every field re-reads on access exactly like the React context\n// object that was rebuilt each render.\nconst context: FormControlContextValue = {\n  get id() {\n    return id();\n  },\n  get labelId() {\n    return `${id()}-label`;\n  },\n  get helperId() {\n    return `${id()}-helper`;\n  },\n  get errorId() {\n    return `${id()}-error`;\n  },\n  get labelledBy() {\n    return chrome.value.label > 0 ? `${id()}-label` : undefined;\n  },\n  get describedBy() {\n    return (\n      [\n        chrome.value.helper > 0 && `${id()}-helper`,\n        chrome.value.error > 0 && `${id()}-error`,\n      ]\n        .filter(Boolean)\n        .join(' ') || undefined\n    );\n  },\n  get errors() {\n    return props.errors;\n  },\n  get isInvalid() {\n    return props.isInvalid;\n  },\n  get isDisabled() {\n    return props.isDisabled;\n  },\n  get isRequired() {\n    return props.isRequired;\n  },\n  get isReadOnly() {\n    return props.isReadOnly;\n  },\n  registerChrome,\n};\n\nprovide(FormControlKey, context);\n</script>\n\n<template>\n  <slot />\n</template>\n"],"names":["_renderSlot"],"mappings":";;;;;;;;;;;;;;AAgCA,UAAM,QAAQ;AAUd,UAAM,cAAc,MAAA;AAEpB,UAAM,SAAS,WAAyB,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG;AAEzE,aAAS,eAAe,MAAyC;AAC/D,aAAO,QAAQ,EAAE,GAAG,OAAO,OAAO,CAAC,IAAI,GAAG,OAAO,MAAM,IAAI,IAAI,EAAA;AAC/D,aAAO,MAAM;AACX,eAAO,QAAQ,EAAE,GAAG,OAAO,OAAO,CAAC,IAAI,GAAG,OAAO,MAAM,IAAI,IAAI,EAAA;AAAA,MACjE;AAAA,IACF;AAEA,UAAM,KAAK,MAAc,MAAM,MAAM;AAIrC,UAAM,UAAmC;AAAA,MACvC,IAAI,KAAK;AACP,eAAO,GAAA;AAAA,MACT;AAAA,MACA,IAAI,UAAU;AACZ,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,MACA,IAAI,WAAW;AACb,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,MACA,IAAI,UAAU;AACZ,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,MACA,IAAI,aAAa;AACf,eAAO,OAAO,MAAM,QAAQ,IAAI,GAAG,GAAA,CAAI,WAAW;AAAA,MACpD;AAAA,MACA,IAAI,cAAc;AAChB,eACE;AAAA,UACE,OAAO,MAAM,SAAS,KAAK,GAAG,IAAI;AAAA,UAClC,OAAO,MAAM,QAAQ,KAAK,GAAG,IAAI;AAAA,QAAA,EAEhC,OAAO,OAAO,EACd,KAAK,GAAG,KAAK;AAAA,MAEpB;AAAA,MACA,IAAI,SAAS;AACX,eAAO,MAAM;AAAA,MACf;AAAA,MACA,IAAI,YAAY;AACd,eAAO,MAAM;AAAA,MACf;AAAA,MACA,IAAI,aAAa;AACf,eAAO,MAAM;AAAA,MACf;AAAA,MACA,IAAI,aAAa;AACf,eAAO,MAAM;AAAA,MACf;AAAA,MACA,IAAI,aAAa;AACf,eAAO,MAAM;AAAA,MACf;AAAA,MACA;AAAA,IAAA;AAGF,YAAQ,gBAAgB,OAAO;;aAI7BA,WAAQ,KAAA,QAAA,SAAA;AAAA;;;"}

package/dist/chunks/HtmlExtensions-jlKY5f9C.js

@@ -0,0 +1,23 @@
+const HtmlElement = {
+  /** Refers to a `<button>` element. */
+  Button: "button",
+  /** Refers to an `<a>` (anchor) element. */
+  Anchor: "a",
+  /** Refers to a `<span>` element. */
+  Span: "span",
+  /** Refers to a `<div>` element. */
+  Div: "div"
+};
+const ButtonType = {
+  /** Refers to a non-submitting button. */
+  Button: "button",
+  /** Refers to a form-submitting button. */
+  Submit: "submit",
+  /** Refers to a form-resetting button. */
+  Reset: "reset"
+};
+export {
+  ButtonType as B,
+  HtmlElement as H
+};
+//# sourceMappingURL=HtmlExtensions-jlKY5f9C.js.map

package/dist/chunks/HtmlExtensions-jlKY5f9C.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HtmlExtensions-jlKY5f9C.js","sources":["../../src/foundation/utils/HtmlExtensions/HtmlExtensions.ts"],"sourcesContent":["/* HTML attribute & element value enums (const + type pairs). */\n\n/** Defines an HTML element tag name (for intrinsic elements and polymorphic components). */\nexport const HtmlElement = {\n  /** Refers to a `<button>` element. */\n  Button: 'button',\n  /** Refers to an `<a>` (anchor) element. */\n  Anchor: 'a',\n  /** Refers to a `<span>` element. */\n  Span: 'span',\n  /** Refers to a `<div>` element. */\n  Div: 'div',\n} as const;\n\nexport type HtmlElement = (typeof HtmlElement)[keyof typeof HtmlElement];\n\n/** Defines the `<button type=\"\">` attribute value. */\nexport const ButtonType = {\n  /** Refers to a non-submitting button. */\n  Button: 'button',\n  /** Refers to a form-submitting button. */\n  Submit: 'submit',\n  /** Refers to a form-resetting button. */\n  Reset: 'reset',\n} as const;\n\nexport type ButtonType = (typeof ButtonType)[keyof typeof ButtonType];\n"],"names":[],"mappings":"AAGO,MAAM,cAAc;AAAA;AAAA,EAEzB,QAAQ;AAAA;AAAA,EAER,QAAQ;AAAA;AAAA,EAER,MAAM;AAAA;AAAA,EAEN,KAAK;AACP;AAKO,MAAM,aAAa;AAAA;AAAA,EAExB,QAAQ;AAAA;AAAA,EAER,QAAQ;AAAA;AAAA,EAER,OAAO;AACT;"}

package/dist/chunks/Icon.vue_vue_type_script_setup_true_lang-DgwdLCRR.js

@@ -0,0 +1,27 @@
+import { defineComponent, useAttrs, computed, openBlock, createBlock, resolveDynamicComponent, normalizeClass, unref } from "vue";
+import { c as cn } from "./cn-CzDCF-Ah.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "Icon" },
+  __name: "Icon",
+  props: {
+    icon: {},
+    size: { default: 20 }
+  },
+  setup(__props) {
+    const attrs = useAttrs();
+    const labelled = computed(() => attrs["aria-label"] != null);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(__props.icon), {
+        size: __props.size,
+        class: normalizeClass(unref(cn)("shrink-0")),
+        "aria-hidden": labelled.value ? void 0 : true,
+        role: labelled.value ? "img" : void 0,
+        focusable: "false"
+      }, null, 8, ["size", "class", "aria-hidden", "role"]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};
+//# sourceMappingURL=Icon.vue_vue_type_script_setup_true_lang-DgwdLCRR.js.map

package/dist/chunks/Icon.vue_vue_type_script_setup_true_lang-DgwdLCRR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Icon.vue_vue_type_script_setup_true_lang-DgwdLCRR.js","sources":["../../src/foundation/icons/Icon.vue"],"sourcesContent":["<script lang=\"ts\">\nimport type { Component, SVGAttributes } from 'vue';\n\nexport interface IconAdapterProps extends SVGAttributes {\n  /**\n   * The pixel size handed to the adapter. `number` only, NOT `number | string`.\n   *\n   * Component props are contravariant: an adapter satisfies this type only if it accepts every\n   * prop declared here. `lucide-vue-next` types its own `size` as `number`, so widening this to\n   * `number | string` — as the React original did, where the looser `SVGProps` made it moot —\n   * makes every lucide icon unassignable to `IconAdapter` and forces an `as unknown as` cast at\n   * each import site. Narrow is the fix; a CSS-unit size belongs on `class`, not on this prop.\n   */\n  size?: number;\n}\n\nexport type IconAdapter = Component<IconAdapterProps>;\n\nexport interface IconProps extends Omit<SVGAttributes, 'aria-hidden'> {\n  /** The icon component — pass a `lucide-vue-next` icon, custom SVG component, or any matching shape. */\n  icon: IconAdapter;\n\n  /** The pixel size of the rendered SVG. Default 20. */\n  size?: number;\n\n  /**\n   * The aria-label for when the icon stands alone (decorative siblings\n   * should pass it via parent). Sets `role=\"img\"` and unhides from AT.\n   * Without it, the icon is `aria-hidden` and decorative.\n   */\n  'aria-label'?: string;\n}\n</script>\n\n<script setup lang=\"ts\">\nimport { computed, useAttrs } from 'vue';\nimport { cn } from '../utils/cn';\n\n/**\n * Generic icon wrapper. Accepts any icon component matching the lucide-vue-next\n * shape (`{ size, color, class, ...svgAttrs }`).\n *\n * - Without `aria-label` → decorative, `aria-hidden`.\n * - With `aria-label` → semantic, `role=\"img\"`.\n *\n * Every other SVG attribute falls through to the rendered icon, and — as with\n * the React original's trailing `{...rest}` — a caller-supplied attribute wins\n * over the wrapper's own binding.\n */\ndefineOptions({ name: 'Icon' });\n\nwithDefaults(\n  defineProps<{\n    /** The icon component — pass a `lucide-vue-next` icon, custom SVG component, or any matching shape. */\n    icon: IconAdapter;\n    /** The pixel size of the rendered SVG. Default 20. */\n    size?: number;\n  }>(),\n  { size: 20 },\n);\n\nconst attrs = useAttrs();\n\n/** `aria-label` arrives as a fallthrough attr; its presence flips the icon from decorative to semantic. */\nconst labelled = computed(() => attrs['aria-label'] != null);\n</script>\n\n<template>\n  <component\n    :is=\"icon\"\n    :size=\"size\"\n    :class=\"cn('shrink-0')\"\n    :aria-hidden=\"labelled ? undefined : true\"\n    :role=\"labelled ? 'img' : undefined\"\n    focusable=\"false\"\n  />\n</template>\n"],"names":["_openBlock","_createBlock","_resolveDynamicComponent","_unref"],"mappings":";;;;;;;;;;AA6DA,UAAM,QAAQ,SAAA;AAGd,UAAM,WAAW,SAAS,MAAM,MAAM,YAAY,KAAK,IAAI;;AAIzD,aAAAA,aAAAC,YAOEC,wBANK,QAAA,IAAI,GAAA;AAAA,QACR,MAAM,QAAA;AAAA,QACN,sBAAOC,MAAA,EAAA,EAAE,UAAA,CAAA;AAAA,QACT,eAAa,SAAA,QAAW,SAAS;AAAA,QACjC,MAAM,SAAA,QAAQ,QAAW;AAAA,QAC1B,WAAU;AAAA,MAAA;;;;"}