@lynx-js/luna-reactlynx 0.0.1

package/dist/theming/create-theme.jsx

@@ -0,0 +1,109 @@
+import { isNonEmptyString } from "./consumption.jsx";
+import { LUNA_COLOR_IDS, colorIdToColorKey, createEmptyLunaColors } from "./identity.jsx";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function createLunaTheme(input, options = {}) {
+    const { consumptionFormat = 'value', cssVarPrefix } = options;
+    const colors = createEmptyLunaColors();
+    if (!hasColors(input)) {
+        if ('var-ref' !== consumptionFormat) throw new Error(formatInvalidInputError({
+            sourceType: 'meta-only',
+            consumptionFormat: `'${consumptionFormat}'`
+        }));
+        return _object_spread({
+            key: input.key,
+            variant: input.variant,
+            mode: input.mode,
+            colors,
+            sourceType: 'meta-only',
+            consumptionFormat: 'var-ref'
+        }, void 0 !== cssVarPrefix ? {
+            cssVarPrefix
+        } : {});
+    }
+    const missingIds = collectMissingColorIds(input.colors);
+    if (missingIds.length > 0) throw new Error(formatMissingColorValuesError(_object_spread({
+        consumptionFormat,
+        sourceType: 'values',
+        missingIds
+    }, void 0 !== cssVarPrefix ? {
+        cssVarPrefix
+    } : {})));
+    for (const id of LUNA_COLOR_IDS){
+        const key = colorIdToColorKey(id);
+        colors[key] = input.colors[id];
+    }
+    Object.freeze(colors);
+    return _object_spread({
+        key: input.key,
+        variant: input.variant,
+        mode: input.mode,
+        colors,
+        sourceType: 'values',
+        consumptionFormat
+    }, void 0 !== cssVarPrefix ? {
+        cssVarPrefix
+    } : {});
+}
+function hasColors(input) {
+    return 'colors' in input && 'object' == typeof input.colors && null !== input.colors;
+}
+function formatInvalidInputError(args) {
+    const { sourceType, consumptionFormat } = args;
+    return [
+        '[createLunaTheme] Invalid theme input for the requested consumption format.',
+        `- sourceType:           '${sourceType}'`,
+        `- consumptionFormat:    ${consumptionFormat}`,
+        '',
+        'A meta-only theme input cannot produce raw values.',
+        'If you want to use CSS variables, pass `consumptionFormat: \'var-ref\'`.'
+    ].join('\n');
+}
+function formatMissingColorValuesError(args) {
+    const { consumptionFormat, sourceType, missingIds, cssVarPrefix } = args;
+    const preview = missingIds.slice(0, 12).join(', ');
+    const more = missingIds.length > 12 ? ` (+${missingIds.length - 12} more)` : '';
+    const prefixHint = void 0 !== cssVarPrefix ? `- cssVarPrefix:          ${cssVarPrefix}\n` : '';
+    return [
+        '[createLunaTheme] Missing required color values.',
+        `- sourceType:            \`${sourceType}\``,
+        `- consumptionFormat:     \`${consumptionFormat}\``,
+        prefixHint.trimEnd(),
+        `- missing color ids:     ${missingIds.length}`,
+        `- missing (preview):     ${preview}${more}`,
+        '',
+        'Note: token values must be complete, even if `consumptionFormat` is `\'var-ref\'`.'
+    ].filter(Boolean).join('\n');
+}
+function collectMissingColorIds(colors) {
+    const missing = [];
+    for (const id of LUNA_COLOR_IDS){
+        const value = colors[id];
+        if (!isNonEmptyString(value)) missing.push(id);
+    }
+    return missing;
+}
+export { createLunaTheme };
+
+//# sourceMappingURL=create-theme.jsx.map

package/dist/theming/identity.d.ts

@@ -0,0 +1,3 @@
+import { LUNA_COLOR_IDS, LUNA_COLOR_KEYS, colorIdToColorKey, colorKeyToColorId, createEmptyLunaColors } from '@lynx-js/luna-core';
+export { LUNA_COLOR_IDS, LUNA_COLOR_KEYS, colorIdToColorKey, colorKeyToColorId, createEmptyLunaColors, };
+//# sourceMappingURL=identity.d.ts.map

package/dist/theming/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/theming/identity.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,GACtB,CAAC"}

package/dist/theming/identity.jsx

@@ -0,0 +1,2 @@
+import { LUNA_COLOR_IDS, LUNA_COLOR_KEYS, colorIdToColorKey, colorKeyToColorId, createEmptyLunaColors } from "@lynx-js/luna-core";
+export { LUNA_COLOR_IDS, LUNA_COLOR_KEYS, colorIdToColorKey, colorKeyToColorId, createEmptyLunaColors };

package/dist/theming/index.d.ts

@@ -0,0 +1,7 @@
+export { LunaThemeContext } from './theme-context.jsx';
+export { LunaThemeProvider } from './theme-provider.jsx';
+export { createLunaTheme } from './create-theme.js';
+export { useLunaThemeContext } from './use-theme-context.js';
+export { useLunaColor } from './use-color.js';
+export { useLunaColors } from './use-colors.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/theming/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/theming/index.jsx

@@ -0,0 +1,7 @@
+import { LunaThemeContext } from "./theme-context.jsx";
+import { LunaThemeProvider } from "./theme-provider.jsx";
+import { createLunaTheme } from "./create-theme.jsx";
+import { useLunaThemeContext } from "./use-theme-context.jsx";
+import { useLunaColor } from "./use-color.jsx";
+import { useLunaColors } from "./use-colors.jsx";
+export { LunaThemeContext, LunaThemeProvider, createLunaTheme, useLunaColor, useLunaColors, useLunaThemeContext };

package/dist/theming/theme-context.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@lynx-js/react';
+import type { LunaThemeContextValue } from './types.js';
+declare const LunaThemeContext: Context<LunaThemeContextValue | null>;
+export { LunaThemeContext };
+//# sourceMappingURL=theme-context.d.ts.map

package/dist/theming/theme-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-context.d.ts","sourceRoot":"","sources":["../../src/theming/theme-context.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,QAAA,MAAM,gBAAgB,EAAE,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAErD,CAAC;AAER,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/theming/theme-context.jsx

@@ -0,0 +1,5 @@
+import { createContext } from "@lynx-js/react";
+const LunaThemeContext = createContext(null);
+export { LunaThemeContext };
+
+//# sourceMappingURL=theme-context.jsx.map

package/dist/theming/theme-provider.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from '@lynx-js/react';
+import type { LunaThemeProviderProps } from './types.js';
+export declare function LunaThemeProvider(props: LunaThemeProviderProps): ReactNode;
+//# sourceMappingURL=theme-provider.d.ts.map

package/dist/theming/theme-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-provider.d.ts","sourceRoot":"","sources":["../../src/theming/theme-provider.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAOhD,OAAO,KAAK,EAAyB,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEhF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,sBAAsB,GAC5B,SAAS,CA2GX"}

package/dist/theming/theme-provider.helpers.d.ts

@@ -0,0 +1,21 @@
+import type { LunaThemeResolveRuleSpec } from '@lynx-js/luna-core';
+/**
+ * Generate a stable string key for resolver rules.
+ *
+ * WHY THIS EXISTS:
+ * - `resolve.rules` may be passed inline by callers (new array/object every render)
+ * - React `useMemo` compares dependencies by reference
+ * - We need a *semantic* equality check, not reference equality
+ *
+ * This function produces a stable, ordered, domain-aware key so that:
+ * - rules with the same meaning => same key
+ * - rules with different order / options => different key
+ *
+ * NOTE:
+ * - This is NOT a general-purpose serializer
+ * - This is intentionally shallow (rules options are config, not data)
+ *
+ * @internal
+ */
+export declare function stableRulesKey(rules: readonly LunaThemeResolveRuleSpec[] | undefined): string;
+//# sourceMappingURL=theme-provider.helpers.d.ts.map

package/dist/theming/theme-provider.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-provider.helpers.d.ts","sourceRoot":"","sources":["../../src/theming/theme-provider.helpers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAEjE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,SAAS,wBAAwB,EAAE,GAAG,SAAS,GACrD,MAAM,CAkBR"}

package/dist/theming/theme-provider.helpers.jsx

@@ -0,0 +1,35 @@
+function stableRulesKey(rules) {
+    if (!rules || 0 === rules.length) return '';
+    return rules.map((rule)=>{
+        if ('string' == typeof rule) return rule;
+        const { id, options } = rule;
+        if (!options || 0 === Object.keys(options).length) return id;
+        const optionPairs = Object.entries(options).sort(([a], [b])=>a.localeCompare(b)).map(([k, v])=>`${k}:${stableAtom(v)}`).join(',');
+        return `${id}(${optionPairs})`;
+    }).join('|');
+}
+function stableAtom(v) {
+    if (null === v) return 'null';
+    if (void 0 === v) return 'undefined';
+    switch(typeof v){
+        case 'string':
+            return JSON.stringify(v);
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+            return String(v);
+        case 'symbol':
+            return v.toString();
+        case 'function':
+            return '[fn]';
+        default:
+            try {
+                return JSON.stringify(v);
+            } catch (e) {
+                return '[unserializable]';
+            }
+    }
+}
+export { stableRulesKey };
+
+//# sourceMappingURL=theme-provider.helpers.jsx.map

package/dist/theming/theme-provider.jsx

@@ -0,0 +1,84 @@
+import { useMemo } from "@lynx-js/react";
+import { resolveThemeObjectFromList } from "@lynx-js/luna-core";
+import { LunaThemeContext } from "./theme-context.jsx";
+import { stableRulesKey } from "./theme-provider.helpers.jsx";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function LunaThemeProvider(props) {
+    var _props_resolve, _props_resolve1, _props_resolve2, _props_resolve3;
+    const rulesKey = stableRulesKey(null == (_props_resolve = props.resolve) ? void 0 : _props_resolve.rules);
+    const resolveStable = useMemo(()=>{
+        var _props_resolve, _props_resolve1, _props_resolve2;
+        return omitUndefined({
+            defaultKey: null == (_props_resolve = props.resolve) ? void 0 : _props_resolve.defaultKey,
+            fallback: null == (_props_resolve1 = props.resolve) ? void 0 : _props_resolve1.fallback,
+            onEmpty: null == (_props_resolve2 = props.resolve) ? void 0 : _props_resolve2.onEmpty
+        });
+    }, [
+        null == (_props_resolve1 = props.resolve) ? void 0 : _props_resolve1.defaultKey,
+        null == (_props_resolve2 = props.resolve) ? void 0 : _props_resolve2.fallback,
+        null == (_props_resolve3 = props.resolve) ? void 0 : _props_resolve3.onEmpty
+    ]);
+    const singleTheme = 'theme' in props ? props.theme : void 0;
+    const themeList = 'themes' in props ? props.themes : void 0;
+    const resolvedThemeKey = 'themes' in props ? props.themeKey : void 0;
+    const value = useMemo(()=>{
+        var _props_resolve;
+        if ('theme' in props) {
+            const theme = props.theme;
+            return {
+                themeKey: theme.key,
+                theme
+            };
+        }
+        const themes = props.themes;
+        if (!themes || 0 === themes.length) throw new Error('[LunaThemeProvider] "themes" must be a non-empty array.');
+        const resolvedKey = props.themeKey;
+        const theme = resolveThemeObjectFromList(themes, resolvedKey, _object_spread({}, resolveStable, (null == (_props_resolve = props.resolve) ? void 0 : _props_resolve.rules) !== void 0 ? {
+            rules: props.resolve.rules
+        } : {}));
+        if (!theme) throw new Error('[LunaThemeProvider] Failed to resolve theme.');
+        return {
+            themeKey: theme.key,
+            theme
+        };
+    }, [
+        singleTheme,
+        themeList,
+        resolvedThemeKey,
+        resolveStable,
+        rulesKey
+    ]);
+    return <LunaThemeContext.Provider value={value}>
+      {props.children}
+    </LunaThemeContext.Provider>;
+}
+function omitUndefined(obj) {
+    const out = {};
+    for (const [k, v] of Object.entries(obj))if (void 0 !== v) out[k] = v;
+    return out;
+}
+export { LunaThemeProvider };
+
+//# sourceMappingURL=theme-provider.jsx.map

package/dist/theming/types.d.ts

@@ -0,0 +1,175 @@
+import type { ReactNode } from '@lynx-js/react';
+import type { LunaColorId, LunaColorKey, LunaCustomThemeKey, LunaCustomThemeMeta, LunaCustomThemeMode, LunaCustomThemeTokens, LunaCustomThemeVariant, LunaThemeResolverOptions, LunaThemeTokens } from '@lynx-js/luna-core';
+export type { LunaColorId, LunaColorKey };
+/**
+ * Values-backed theme input that provides concrete token values.
+ *
+ * Contract:
+ * - Provide concrete raw values (canonical truth).
+ * - Token values must be complete (all required ids must be present).
+ *
+ * Notes:
+ * - This type describes the semantic contract ("values-backed"),
+ *   not the source mechanism (tokens).
+ */
+export type LunaThemeValueInput = LunaThemeTokens | LunaCustomThemeTokens;
+/**
+ * Public-friendly alias: token-driven input.
+ *
+ * @remarks
+ * Today values-backed inputs are provided via tokens,
+ * hence the name. Internally we keep "ValueInput"
+ * to avoid coupling the contract to a specific mechanism.
+ */
+export type LunaThemeTokenInput = LunaThemeValueInput;
+/**
+ * Public-friendly alias for meta-only theme input.
+ *
+ * @remarks
+ * Meta-only inputs do not provide concrete token values.
+ * They are intended for CSS-variable–only or metadata-driven
+ * theme definitions.
+ *
+ * Internally this maps to `LunaCustomThemeMeta`.
+ */
+export type LunaThemeMetaInput = LunaCustomThemeMeta;
+/**
+ * Theme inputs accepted by createLunaTheme.
+ *
+ * - `LunaThemeTokenInput` (values-backed): provides concrete token values
+ * - `LunaCustomThemeMeta` (meta-only): no token values
+ */
+export type LunaThemeInput = LunaThemeValueInput | LunaThemeMetaInput;
+export type LunaRuntimeThemeSourceType = 
+/** Values-backed input that provides concrete token values */
+'values'
+/** Meta-only input without token values */
+ | 'meta-only';
+export type LunaRuntimeThemeConsumptionFormat = 
+/** raw values */
+'value'
+/** `var(--prefix-id)` references */
+ | 'var-ref';
+/**
+ * Runtime theme object consumed by LunaThemeProvider and hooks.
+ *
+ * Key points:
+ * - `colors` and future surfaces like `typography` and `radii`
+ *   store canonical raw values when `sourceType: 'values'`.
+ * - CSS variable references are computed on demand (from token ids),
+ *   and should not be stored into `colors` or other value surfaces.
+ */
+export type LunaRuntimeTheme = {
+    key: LunaCustomThemeKey;
+    variant: LunaCustomThemeVariant;
+    mode: LunaCustomThemeMode;
+    /**
+     * Canonical color values.
+     *
+     * - When `sourceType: 'values'`, this must be a complete raw value surface.
+     * - When `sourceType: 'meta-only'`, values are not available; this stays as
+     *   the empty template for shape stability.
+     */
+    colors: Readonly<Record<LunaColorKey, string>>;
+    /**
+     * Where this runtime theme comes from.
+     */
+    sourceType: LunaRuntimeThemeSourceType;
+    /**
+     * Describe how theme values should be consumed by default.
+     *
+     * This applies to all runtime theme surfaces (e.g. `colors`,
+     * and future surfaces like typography, radius, or spacing).
+     *
+     * - `'value'`: consumers read raw values from runtime surfaces
+     * - `'var-ref'`: consumers read css-var references generated from token ids
+     */
+    consumptionFormat: LunaRuntimeThemeConsumptionFormat;
+    /**
+     * Optional metadata for css-var pipeline.
+     *
+     * If omitted, variables are generated without a prefix:
+     * - `'var-name'`: `--neutral`
+     * - `'var-ref'`:  `var(--neutral)`
+     */
+    cssVarPrefix?: string;
+};
+export type LunaThemeContextValue = {
+    themeKey: LunaCustomThemeKey;
+    theme: LunaRuntimeTheme;
+};
+export type CreateLunaThemeOptions = {
+    /**
+     * Decide how theme values should be consumed by default in the runtime theme.
+     *
+     * Notes:
+     * - This does NOT change what is stored in `runtimeTheme.colors` or other value surfaces.
+     * - For values-backed inputs, `colors` always stores raw values.
+     * - For meta-only inputs, `'value'` is invalid.
+     *
+     * - `'value'`: default consumption uses raw values
+     * - `'var-ref'`: default consumption uses css-var references
+     *
+     * @defaultValue `'value'`
+     */
+    consumptionFormat?: LunaRuntimeThemeConsumptionFormat;
+    /**
+     * CSS var prefix used when consuming `'var-ref'` / generating `'var-name'`.
+     */
+    cssVarPrefix?: string;
+};
+type LunaThemeProviderCommonProps = {
+    /**
+     * Theme resolver options controlling resolution behavior
+     *
+     * @remarks
+     * Only takes effect in list mode (when `themes` is provided).
+     * Ignored in single-theme mode.
+     */
+    resolve?: LunaThemeResolverOptions;
+    children?: ReactNode;
+};
+export type LunaThemeProviderSingleThemeProps = {
+    /** Single theme entry (MUI-style) */
+    theme: LunaRuntimeTheme;
+    /** Must not be provided in single-theme mode */
+    themes?: never;
+    themeKey?: never;
+} & LunaThemeProviderCommonProps;
+export type LunaThemeProviderThemeListProps = {
+    /** Theme list for routing */
+    themes: LunaRuntimeTheme[];
+    /** Optional requested theme key */
+    themeKey?: LunaCustomThemeKey;
+    /** Must not be provided in list mode */
+    theme?: never;
+} & LunaThemeProviderCommonProps;
+export type LunaThemeProviderProps = LunaThemeProviderSingleThemeProps | LunaThemeProviderThemeListProps;
+export type LunaConsumptionOptions = {
+    /**
+     * - `'result'`: return the resolved consumption result based on `format` (`'value'` or `'var-ref'`)
+     * - `'var-name'`: return a CSS custom property name (e.g. `--neutral`)
+     *
+     * Notes:
+     * - `format` only applies when `as: 'result'`.
+     *
+     * @defaultValue `'result'`
+     */
+    as?: 'result' | 'var-name';
+    /**
+     * Override how the result is produced for consumption.
+     *
+     * - `'value'`: return raw values
+     * - `'var-ref'`: return a CSS variable reference (e.g. `var(--neutral)`)
+     */
+    format?: LunaRuntimeThemeConsumptionFormat;
+    /**
+     * Optional override for css var prefix.
+     *
+     * If omitted, uses `theme.cssVarPrefix`.
+     */
+    cssVarPrefix?: string;
+};
+export type UseLunaColorOptions = LunaConsumptionOptions;
+export type UseLunaColorsOptions = LunaConsumptionOptions;
+//# sourceMappingURL=types.d.ts.map

package/dist/theming/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/theming/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,EACxB,eAAe,EAChB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC;AAM1C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,mBAAmB,GAC3B,eAAe,GACf,qBAAqB,CAAC;AAE1B;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;AAEtD;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,CAAC;AAErD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB,mBAAmB,GACnB,kBAAkB,CAAC;AAMvB,MAAM,MAAM,0BAA0B;AACpC,8DAA8D;AAC5D,QAAQ;AACV,2CAA2C;GACzC,WAAW,CAAC;AAEhB,MAAM,MAAM,iCAAiC;AAC3C,iBAAiB;AACf,OAAO;AACT,oCAAoC;GAClC,SAAS,CAAC;AAEd;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,kBAAkB,CAAC;IACxB,OAAO,EAAE,sBAAsB,CAAC;IAChC,IAAI,EAAE,mBAAmB,CAAC;IAE1B;;;;;;OAMG;IACH,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IAE/C;;OAEG;IACH,UAAU,EAAE,0BAA0B,CAAC;IAEvC;;;;;;;;OAQG;IACH,iBAAiB,EAAE,iCAAiC,CAAC;IAErD;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAMF,MAAM,MAAM,sBAAsB,GAAG;IACnC;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,EAAE,iCAAiC,CAAC;IAEtD;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAMF,KAAK,4BAA4B,GAAG;IAClC;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,wBAAwB,CAAC;IAEnC,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,iCAAiC,GAAG;IAC9C,qCAAqC;IACrC,KAAK,EAAE,gBAAgB,CAAC;IAExB,gDAAgD;IAChD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,QAAQ,CAAC,EAAE,KAAK,CAAC;CAClB,GAAG,4BAA4B,CAAC;AAEjC,MAAM,MAAM,+BAA+B,GAAG;IAC5C,6BAA6B;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAE3B,mCAAmC;IACnC,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAE9B,wCAAwC;IACxC,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,GAAG,4BAA4B,CAAC;AAEjC,MAAM,MAAM,sBAAsB,GAC9B,iCAAiC,GACjC,+BAA+B,CAAC;AAMpC,MAAM,MAAM,sBAAsB,GAAG;IACnC;;;;;;;;OAQG;IACH,EAAE,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IAE3B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,iCAAiC,CAAC;IAE3C;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,sBAAsB,CAAC;AAEzD,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,CAAC"}

package/dist/theming/use-color.d.ts

@@ -0,0 +1,3 @@
+import type { LunaColorKey, UseLunaColorOptions } from './types.js';
+export declare function useLunaColor(options?: UseLunaColorOptions): (key: LunaColorKey) => string;
+//# sourceMappingURL=use-color.d.ts.map

package/dist/theming/use-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-color.d.ts","sourceRoot":"","sources":["../../src/theming/use-color.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGpE,wBAAgB,YAAY,CAC1B,OAAO,GAAE,mBAAwB,GAChC,CAAC,GAAG,EAAE,YAAY,KAAK,MAAM,CAmD/B"}

package/dist/theming/use-color.jsx

@@ -0,0 +1,55 @@
+import { useCallback, useMemo } from "@lynx-js/react";
+import { formatMetaOnlyValueError, resolveConsumptionFormat, toVarName } from "./consumption.jsx";
+import { colorKeyToColorId } from "./identity.jsx";
+import { useLunaThemeContext } from "./use-theme-context.jsx";
+function useLunaColor(options = {}) {
+    const ctx = useLunaThemeContext();
+    if (!ctx) throw new Error('[useLunaColor] must be used within <LunaThemeProvider>.');
+    const { theme } = ctx;
+    const { as = 'result', format, cssVarPrefix } = options;
+    const resolved = useMemo(()=>resolveConsumptionFormat({
+            as,
+            format,
+            themeFormat: theme.consumptionFormat
+        }), [
+        as,
+        format,
+        theme.consumptionFormat
+    ]);
+    const prefix = useMemo(()=>null != cssVarPrefix ? cssVarPrefix : theme.cssVarPrefix, [
+        cssVarPrefix,
+        theme.cssVarPrefix
+    ]);
+    const getColor = useCallback((key)=>{
+        const id = colorKeyToColorId(key);
+        const varName = toVarName({
+            id,
+            cssVarPrefix: prefix
+        });
+        switch(resolved.kind){
+            case 'var-name':
+                return varName;
+            case 'var-ref':
+                return `var(${varName})`;
+            case 'value':
+                if ('values' !== theme.sourceType) throw new Error(formatMetaOnlyValueError({
+                    hook: 'useLunaColor'
+                }));
+                return theme.colors[key];
+            default:
+                return assertNever(resolved);
+        }
+    }, [
+        resolved,
+        prefix,
+        theme.sourceType,
+        theme.colors
+    ]);
+    return getColor;
+}
+function assertNever(x) {
+    throw new Error(`[useLunaColor] Unexpected resolved.kind: ${String(x)}`);
+}
+export { useLunaColor };
+
+//# sourceMappingURL=use-color.jsx.map

package/dist/theming/use-colors.d.ts

@@ -0,0 +1,11 @@
+import type { LunaColorKey, UseLunaColorsOptions } from './types.js';
+/**
+ * Batch version of `useLunaColor`.
+ *
+ * Contract:
+ * - Returns an immutable snapshot.
+ * - In "value" mode, returns the theme's canonical colors surface.
+ * - In var modes, returns a derived surface (also immutable).
+ */
+export declare function useLunaColors(options?: UseLunaColorsOptions): Readonly<Record<LunaColorKey, string>>;
+//# sourceMappingURL=use-colors.d.ts.map

package/dist/theming/use-colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-colors.d.ts","sourceRoot":"","sources":["../../src/theming/use-colors.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGrE;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,OAAO,GAAE,oBAAyB,GACjC,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAiDxC"}

package/dist/theming/use-colors.jsx

@@ -0,0 +1,45 @@
+import { useMemo } from "@lynx-js/react";
+import { formatMetaOnlyValueError, resolveConsumptionFormat, toVarName } from "./consumption.jsx";
+import { LUNA_COLOR_KEYS, colorKeyToColorId } from "./identity.jsx";
+import { useLunaThemeContext } from "./use-theme-context.jsx";
+function useLunaColors(options = {}) {
+    const ctx = useLunaThemeContext();
+    if (!ctx) throw new Error('[useLunaColors] must be used within <LunaThemeProvider>.');
+    const { theme } = ctx;
+    const { as = 'result', format, cssVarPrefix } = options;
+    return useMemo(()=>{
+        const resolved = resolveConsumptionFormat({
+            as,
+            format,
+            themeFormat: theme.consumptionFormat
+        });
+        if ('value' === resolved.kind) {
+            if ('values' !== theme.sourceType) throw new Error(formatMetaOnlyValueError({
+                hook: 'useLunaColors'
+            }));
+            return theme.colors;
+        }
+        const prefix = null != cssVarPrefix ? cssVarPrefix : theme.cssVarPrefix;
+        const out = {};
+        for (const key of LUNA_COLOR_KEYS){
+            const id = colorKeyToColorId(key);
+            const varName = toVarName({
+                id,
+                cssVarPrefix: prefix
+            });
+            out[key] = 'var-name' === resolved.kind ? varName : `var(${varName})`;
+        }
+        return Object.freeze(out);
+    }, [
+        as,
+        cssVarPrefix,
+        format,
+        theme.consumptionFormat,
+        theme.sourceType,
+        theme.colors,
+        theme.cssVarPrefix
+    ]);
+}
+export { useLunaColors };
+
+//# sourceMappingURL=use-colors.jsx.map

package/dist/theming/use-theme-context.d.ts

@@ -0,0 +1,7 @@
+import type { LunaThemeContextValue } from './types.js';
+/**
+ * Internal hook.
+ * Returns theme context or null if no provider is found.
+ */
+export declare function useLunaThemeContext(): LunaThemeContextValue | null;
+//# sourceMappingURL=use-theme-context.d.ts.map

package/dist/theming/use-theme-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-theme-context.d.ts","sourceRoot":"","sources":["../../src/theming/use-theme-context.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,qBAAqB,GAAG,IAAI,CAElE"}

package/dist/theming/use-theme-context.jsx

@@ -0,0 +1,8 @@
+import { useContext } from "@lynx-js/react";
+import { LunaThemeContext } from "./theme-context.jsx";
+function useLunaThemeContext() {
+    return useContext(LunaThemeContext);
+}
+export { useLunaThemeContext };
+
+//# sourceMappingURL=use-theme-context.jsx.map