@animus-ui/system 0.1.20 → 0.1.22

package/dist/appearance/controller.d.ts

@@ -0,0 +1,35 @@
+import { t as AppearanceStorageOptions } from "../index-BjJkQo64.js";
+//#region src/appearance/controller.d.ts
+export interface ColorModeControllerOptions {
+  /** The modes the theme declares, such as `Object.keys(theme.manifest.modes)`. */
+  modes: readonly string[];
+  /** The setting before one is made: a declared mode or `system`, the
+   *  default. A stored setting replaces it when storage is enabled. */
+  initial?: string;
+  /**
+   * Off unless given. When enabled, the initial setting is read from the
+   * appearance record as the bootstrap reads it, and each change is written
+   * through `persistColorMode`.
+   */
+  storage?: boolean | AppearanceStorageOptions;
+}
+export interface ColorModeController {
+  /** A declared mode, or `system`. */
+  get(): string;
+  /** The setting before storage is read: what a server renders. */
+  getDefault(): string;
+  /** Writes `data-color-mode` on the root by the bootstrap's rules: a
+   *  declared mode as is, `system` by removing the attribute. */
+  set(mode: string): void;
+  /** Calls `listener` after each change; returns the unsubscriber. */
+  subscribe(listener: (mode: string) => void): () => void;
+}
+/**
+ * Holds the light/dark setting for one theme: any mode it declares, or
+ * `system`, which leaves the choice to the operating system's preference
+ * through CSS. It never queries the operating system, and writes nothing,
+ * neither the root attribute nor storage, until `set` is called.
+ */
+export declare function createColorModeController(options: ColorModeControllerOptions): ColorModeController;
+//#endregion
+//# sourceMappingURL=controller.d.ts.map

package/dist/appearance/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","names":[],"sources":["../../src/appearance/controller.ts"],"mappings":";;iBAWiB;;EAEf;;;EAGA;;;;;;EAMA,oBAAoB;;iBAGL;;EAEf;;EAEA;;;EAGA,IAAI;;EAEJ,UAAU,WAAW;;;;;;;;wBAyDP,0BACd,SAAS,6BACR"}

package/dist/appearance/controller.js

@@ -0,0 +1,69 @@
+import { SYSTEM_MODE, persistColorMode } from "./index.js";
+//#region src/appearance/controller.ts
+const DEFAULT_STORAGE_KEY = "animus:appearance";
+const SHARED_LEGACY_KEY = "color-mode";
+const MODE_ATTRIBUTE = "data-color-mode";
+const RECORD_VERSION = 1;
+/** The setting the bootstrap restores: the record's mode, or the shared
+*  legacy key when no record is stored. Null when nothing applies. */
+function storedSetting(storageKey, modes) {
+	const storage = globalThis.localStorage;
+	const read = (key) => {
+		try {
+			return storage?.getItem(key) ?? null;
+		} catch {
+			return null;
+		}
+	};
+	const declared = (mode) => modes.some((name) => name === mode);
+	const raw = read(storageKey);
+	if (raw === null || raw === "") {
+		const legacy = read(SHARED_LEGACY_KEY);
+		return declared(legacy) ? legacy : null;
+	}
+	let record;
+	try {
+		record = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	return record?.v === RECORD_VERSION && declared(record.mode) ? record.mode : SYSTEM_MODE;
+}
+/**
+* Holds the light/dark setting for one theme: any mode it declares, or
+* `system`, which leaves the choice to the operating system's preference
+* through CSS. It never queries the operating system, and writes nothing,
+* neither the root attribute nor storage, until `set` is called.
+*/
+function createColorModeController(options) {
+	const { modes, storage } = options;
+	const valid = (mode) => mode === "system" || modes.includes(mode);
+	const fallback = options.initial ?? "system";
+	if (!valid(fallback)) throw new Error(`colorMode: initial '${fallback}' is neither a declared mode nor '${SYSTEM_MODE}'.`);
+	const storageOptions = storage === void 0 || storage === false ? null : storage === true ? {} : storage;
+	if (storageOptions?.storageKey === "") throw new Error("colorMode: storageKey must be a non-empty string.");
+	let current = (storageOptions && storedSetting(storageOptions.storageKey ?? DEFAULT_STORAGE_KEY, modes)) ?? fallback;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get: () => current,
+		getDefault: () => fallback,
+		set(mode) {
+			if (!valid(mode)) throw new Error(`colorMode: '${mode}' is neither a declared mode nor '${SYSTEM_MODE}'.`);
+			const root = globalThis.document?.documentElement;
+			if (mode === "system") root?.removeAttribute(MODE_ATTRIBUTE);
+			else root?.setAttribute(MODE_ATTRIBUTE, mode);
+			if (storageOptions) persistColorMode(mode, storageOptions);
+			if (mode === current) return;
+			current = mode;
+			for (const listener of [...listeners]) listener(mode);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+export { createColorModeController };

package/dist/appearance/index.d.ts

@@ -1,7 +1,2 @@
-export declare const SYSTEM_MODE = "system";
-export interface AppearanceStorageOptions {
-    storageKey?: string;
-}
-export declare function persistColorMode(mode: string, options?: AppearanceStorageOptions): void;
-export declare function migrateLegacyModeKey(legacyKey: string, declaredModes: readonly string[], options?: AppearanceStorageOptions): string | null;
-//# sourceMappingURL=index.d.ts.map
+import { i as persistColorMode, n as SYSTEM_MODE, r as migrateLegacyModeKey, t as AppearanceStorageOptions } from "../index-BjJkQo64.js";
+export { AppearanceStorageOptions, SYSTEM_MODE, migrateLegacyModeKey, persistColorMode };

package/dist/appearance/react.d.ts

@@ -0,0 +1,10 @@
+import { ColorModeController } from "./controller.js";
+//#region src/appearance/react.d.ts
+/**
+ * The controller's setting and its setter. A server render, and the first
+ * client render that hydrates it, read the default setting, so a stored
+ * setting arrives in the render after hydration.
+ */
+export declare function useColorMode(controller: ColorModeController): [mode: string, setMode: (mode: string) => void];
+//#endregion
+//# sourceMappingURL=react.d.ts.map

package/dist/appearance/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","names":[],"sources":["../../src/appearance/react.ts"],"mappings":";;;;;;;wBASgB,aACd,YAAY,uBACV,cAAc,UAAU"}

package/dist/appearance/react.js

@@ -0,0 +1,12 @@
+import { useSyncExternalStore } from "react";
+//#region src/appearance/react.ts
+/**
+* The controller's setting and its setter. A server render, and the first
+* client render that hydrates it, read the default setting, so a stored
+* setting arrives in the render after hydration.
+*/
+function useColorMode(controller) {
+	return [useSyncExternalStore(controller.subscribe, controller.get, controller.getDefault), controller.set];
+}
+//#endregion
+export { useColorMode };

package/dist/appearance/svelte.d.ts

@@ -0,0 +1,12 @@
+import { ColorModeController } from "./controller.js";
+//#region src/appearance/svelte.d.ts
+/** Svelte's writable store contract, restated so `svelte` is not imported. */
+export interface ColorModeStore {
+  subscribe(run: (mode: string) => void): () => void;
+  set(mode: string): void;
+}
+/** The controller as a Svelte store: `$store` reads the setting, and
+ *  `$store = 'dark'` sets it. */
+export declare function colorModeStore(controller: ColorModeController): ColorModeStore;
+//#endregion
+//# sourceMappingURL=svelte.d.ts.map

package/dist/appearance/svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte.d.ts","names":[],"sources":["../../src/appearance/svelte.ts"],"mappings":";;;iBAGiB;EACf,UAAU,MAAM;EAChB,IAAI;;;;wBAKU,eACd,YAAY,sBACX"}

package/dist/appearance/svelte.js

@@ -0,0 +1,14 @@
+//#region src/appearance/svelte.ts
+/** The controller as a Svelte store: `$store` reads the setting, and
+*  `$store = 'dark'` sets it. */
+function colorModeStore(controller) {
+	return {
+		subscribe(run) {
+			run(controller.get());
+			return controller.subscribe(run);
+		},
+		set: controller.set
+	};
+}
+//#endregion
+export { colorModeStore };

package/dist/bootstrap/index.d.ts

@@ -1,2 +1,25 @@
-export { type AppearanceBootstrapArtifact, type AppearanceBootstrapOptions, type AppearanceBootstrapTheme, createAppearanceBootstrap, } from './createAppearanceBootstrap.js';
+//#region src/bootstrap/createAppearanceBootstrap.d.ts
+interface AppearanceBootstrapTheme {
+  manifest: {
+    modes?: Record<string, unknown>;
+  };
+}
+interface AppearanceBootstrapOptions {
+  storageKey?: string;
+  /**
+   * Keys your application owns that hold a bare mode name from before the
+   * appearance record. Before paint, each is migrated as
+   * `migrateLegacyModeKey` migrates it, in order, so the first declared mode
+   * becomes the record when none exists. An undeclared value is removed,
+   * never applied. The shared `color-mode` key stays read-only.
+   */
+  legacyKeys?: readonly string[];
+}
+interface AppearanceBootstrapArtifact {
+  code: string;
+  cspHash: string;
+}
+export declare function createAppearanceBootstrap(theme: AppearanceBootstrapTheme, options?: AppearanceBootstrapOptions): AppearanceBootstrapArtifact;
+//#endregion
+export type { AppearanceBootstrapArtifact, AppearanceBootstrapOptions, AppearanceBootstrapTheme };
 //# sourceMappingURL=index.d.ts.map

package/dist/bootstrap/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bootstrap/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,yBAAyB,GAC1B,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/bootstrap/createAppearanceBootstrap.ts"],"mappings":";UAYiB;EACf;IACE,QAAQ;;;UAIK;EACf;;;;;;;;EAQA;;UAGe;EACf;EACA;;wBA0Bc,0BACd,OAAO,0BACP,UAAS,6BACR"}

package/dist/bootstrap/index.js

@@ -28,13 +28,21 @@ function inlineLiteral(value) {
 	return out;
 }
 function createAppearanceBootstrap(theme, options = {}) {
-	const { storageKey = DEFAULT_STORAGE_KEY } = options;
+	const { storageKey = DEFAULT_STORAGE_KEY, legacyKeys = [] } = options;
 	if (typeof storageKey !== "string" || storageKey === "") throw new Error("createAppearanceBootstrap: storageKey must be a non-empty string.");
+	for (const legacyKey of legacyKeys) {
+		if (typeof legacyKey !== "string" || legacyKey === "") throw new Error("createAppearanceBootstrap: each legacy key must be a non-empty string.");
+		if (legacyKey === LEGACY_STORAGE_KEY) throw new Error(`createAppearanceBootstrap: '${LEGACY_STORAGE_KEY}' is the contract's shared legacy key — the bootstrap reads it read-only and it may belong to another app on this origin. List only keys your application owns.`);
+		if (legacyKey === storageKey) throw new Error(`createAppearanceBootstrap: legacy key '${legacyKey}' is the record key itself — nothing to migrate.`);
+	}
 	const modeNames = Object.keys(theme?.manifest?.modes ?? {}).sort();
 	if (modeNames.length === 0) throw new Error("createAppearanceBootstrap: the theme declares no color modes — call addColorModes() before generating a bootstrap.");
 	if (modeNames.includes(RESERVED_MODE_NAME)) throw new Error(`createAppearanceBootstrap: '${RESERVED_MODE_NAME}' is a reserved mode name — the OS preference is represented by the absence of the ${MODE_ATTRIBUTE} attribute, never by a declared mode.`);
 	if (modeNames.some((name) => name.trim() === "")) throw new Error("createAppearanceBootstrap: a declared mode name is empty or whitespace-only — such a name matches no mode block and would suppress the system fallback.");
-	const code = `(function(){try{var m=${`[${modeNames.map(inlineLiteral).join(",")}]`};var r=document.documentElement;var v=null;try{v=localStorage.getItem(${inlineLiteral(storageKey)});}catch(e){v=null;}var n=null;if(typeof v==="string"&&v!==""){var p;try{p=JSON.parse(v);}catch(e){return;}n=p&&typeof p==="object"&&p.v===${RECORD_VERSION}?p.mode:null;}else{try{n=localStorage.getItem(${inlineLiteral(LEGACY_STORAGE_KEY)});}catch(e){n=null;}}if(typeof n==="string"&&m.indexOf(n)!==-1){r.setAttribute(${inlineLiteral(MODE_ATTRIBUTE)},n);}else{r.removeAttribute(${inlineLiteral(MODE_ATTRIBUTE)});}}catch(e){}})();`;
+	const allowlist = `[${modeNames.map(inlineLiteral).join(",")}]`;
+	const record = inlineLiteral(storageKey);
+	const migration = legacyKeys.length === 0 ? "" : `var k=[${legacyKeys.map(inlineLiteral).join(",")}];for(var i=0;k.length>i;i++){try{var g=localStorage,w=g.getItem(${record}),a=1;if(w){try{var q=JSON.parse(w);a=!(q&&typeof q==="object"&&!Array.isArray(q));}catch(e){}}var l=a?g.getItem(k[i]):null;if(m.indexOf(l)!==-1)g.setItem(${record},JSON.stringify({v:${RECORD_VERSION},mode:l,theme:"default"}));g.removeItem(k[i]);}catch(e){}}`;
+	const code = `(function(){try{var m=${allowlist};` + migration + `var r=document.documentElement;var v=null;try{v=localStorage.getItem(${record});}catch(e){v=null;}var n=null;if(typeof v==="string"&&v!==""){var p;try{p=JSON.parse(v);}catch(e){return;}n=p&&typeof p==="object"&&p.v===${RECORD_VERSION}?p.mode:null;}else{try{n=localStorage.getItem(${inlineLiteral(LEGACY_STORAGE_KEY)});}catch(e){n=null;}}if(typeof n==="string"&&m.indexOf(n)!==-1){r.setAttribute(${inlineLiteral(MODE_ATTRIBUTE)},n);}else{r.removeAttribute(${inlineLiteral(MODE_ATTRIBUTE)});}}catch(e){}})();`;
 	return {
 		code,
 		cspHash: `sha256-${createHash("sha256").update(code, "utf8").digest("base64")}`

package/dist/class-resolver.d.ts

@@ -1,6 +1,2 @@
-/**
- * Excludes the React component runtime so non-React consumers can bundle
- * class resolvers without installing React.
- */
-export { type ClassResolver, type ClassResolverAttributes, createClassResolver, } from './runtime/createClassResolver.js';
-//# sourceMappingURL=class-resolver.d.ts.map
+import { n as ClassResolverAttributes, r as createClassResolver, t as ClassResolver } from "./createClassResolver-Do1nmvkf.js";
+export { type ClassResolver, type ClassResolverAttributes, createClassResolver };

package/dist/class-resolver.js

@@ -1,2 +1,2 @@
-import { t as createClassResolver } from "./createClassResolver-DPLExqGy.js";
+import { t as createClassResolver } from "./createClassResolver-DtHjTYa7.js";
 export { createClassResolver };