@react-native-rethemed/core 0.1.0 → 0.1.1

package/dist/esm/color-mode-store.js

@@ -1,59 +0,0 @@
-export const isColorMode = (value) => value === 'light' || value === 'dark' || value === 'system';
-/**
- * External store holding the uncontrolled color mode. One is created per
- * `createThemed()` call (never at module level) so independent instances
- * don't share state.
- */
-export function createColorModeStore() {
-    let mode = null;
-    // Set once the user picks a mode, so a late rehydration can't override it.
-    let userSet = false;
-    let hydrationStarted = false;
-    const listeners = new Set();
-    const emit = () => {
-        for (const listener of listeners)
-            listener();
-    };
-    return {
-        /**
-         * Seeds the mode on first use only. Called during render so the very
-         * first render already sees `defaultMode`; later calls (e.g. a changed
-         * `defaultColorMode` prop) are ignored rather than overwriting the
-         * current mode.
-         */
-        init(defaultMode) {
-            if (mode === null)
-                mode = defaultMode;
-        },
-        subscribe(listener) {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        getSnapshot() {
-            return mode ?? 'system';
-        },
-        setMode(next) {
-            userSet = true;
-            if (next === mode)
-                return;
-            mode = next;
-            emit();
-        },
-        /** Returns `false` if rehydration already ran for this store. */
-        beginHydration() {
-            if (hydrationStarted)
-                return false;
-            hydrationStarted = true;
-            return true;
-        },
-        /** Applies a stored value unless it's malformed or the user already chose. */
-        hydrate(saved) {
-            if (userSet || !isColorMode(saved) || saved === mode)
-                return;
-            mode = saved;
-            emit();
-        },
-    };
-}

package/dist/esm/config.d.ts

@@ -1,14 +0,0 @@
-/**
- * `@react-native-rethemed/core/config` — the React/RN-free part of core.
- *
- * Apps can import everything from the package root: the CLI stubs
- * `react-native` when it evaluates a theme file. Core's own token packages
- * still import from here so they never depend on that stub.
- */
-export { defineTheme } from './define-theme.js';
-export { extendTheme } from './extend-theme.js';
-export { RN_DEFAULT_FONT_SIZE, resolveBaseFontSize, } from './resolvers/line-height-resolver.js';
-export { isSchemeColor, walkSemanticColors } from './semantic-colors.js';
-export { COLOR_KEYS, FONT_SIZE_KEYS, FONT_WEIGHT_KEYS, LETTER_SPACING_KEYS, LINE_HEIGHT_KEYS, RADIUS_KEYS, SHADOW_STYLE_PROPS, SPACING_KEYS, Z_INDEX_KEYS, } from './style-props.js';
-export { isTextPreset, resolveTextColor, TEXT_TOKEN_FIELDS, walkTextPresets, } from './text-tree.js';
-export type { LooseSchema, SchemeColor, SemanticColors, ShadowToken, TextColor, TextToken, TextTokenTree, ThemeConfig, ThemedSchema, ThemedStyles, TokenizeStyle, } from './types.js';

package/dist/esm/config.js

@@ -1,13 +0,0 @@
-/**
- * `@react-native-rethemed/core/config` — the React/RN-free part of core.
- *
- * Apps can import everything from the package root: the CLI stubs
- * `react-native` when it evaluates a theme file. Core's own token packages
- * still import from here so they never depend on that stub.
- */
-export { defineTheme } from './define-theme.js';
-export { extendTheme } from './extend-theme.js';
-export { RN_DEFAULT_FONT_SIZE, resolveBaseFontSize, } from './resolvers/line-height-resolver.js';
-export { isSchemeColor, walkSemanticColors } from './semantic-colors.js';
-export { COLOR_KEYS, FONT_SIZE_KEYS, FONT_WEIGHT_KEYS, LETTER_SPACING_KEYS, LINE_HEIGHT_KEYS, RADIUS_KEYS, SHADOW_STYLE_PROPS, SPACING_KEYS, Z_INDEX_KEYS, } from './style-props.js';
-export { isTextPreset, resolveTextColor, TEXT_TOKEN_FIELDS, walkTextPresets, } from './text-tree.js';

package/dist/esm/create-themed-styles.js

@@ -1,34 +0,0 @@
-import { createStyleResolver } from './resolvers/style-resolver.js';
-import { resolveTextTree } from './text-tree.js';
-import { createTextVariants } from './text-variants.js';
-/**
- * Builds `{ view, text, image }` from a fully resolved `ThemeConfig` for one
- * fixed color scheme. No React here — plain data in, plain functions out.
- * `createThemed` calls this once per scheme and hands the result out through
- * `useThemed()`, so components re-render (and pick up new colors) when the
- * scheme changes.
- *
- * `S` comes from the generated `themed.gen.ts`; without it every token
- * prop is loosely typed (`LooseSchema`).
- */
-export function createThemedStyles(config, scheme) {
-    // One pass over the input's keys per call; see `createStyleResolver`.
-    const resolveStyle = createStyleResolver(config, scheme);
-    const text = (input = {}) => resolveStyle(input);
-    // Preset colors (`{ light, dark }`) are picked for this scheme up front.
-    const variants = createTextVariants(resolveTextTree(config.semanticTokens?.text, scheme), (input) => resolveStyle(input));
-    // `Object.assign` would throw for roles that collide with non-writable
-    // function properties (`name`, `length`); defineProperty overrides them.
-    for (const [role, sizes] of Object.entries(variants)) {
-        Object.defineProperty(text, role, {
-            value: sizes,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return {
-        view: resolveStyle,
-        image: resolveStyle,
-        text,
-    };
-}

package/dist/esm/create-themed.d.ts

@@ -1,46 +0,0 @@
-import { type ReactNode } from 'react';
-import { type ColorMode, type ColorModeStorage } from './color-mode-store.js';
-import { type ColorScheme } from './resolvers/color-resolver.js';
-import type { LooseSchema, ThemeConfig, ThemedSchema, ThemedStyles } from './types.js';
-export type { ColorMode, ColorModeStorage, ColorScheme };
-export type ThemedProviderProps = {
-    children?: ReactNode;
-    /**
-     * Controlled mode: the app owns the scheme and this value is used as-is.
-     * When set, `defaultColorMode`/`storage`/`storageKey` are ignored.
-     */
-    colorScheme?: ColorScheme;
-    /** Uncontrolled initial mode. Only read the first time the store is used. */
-    defaultColorMode?: ColorMode;
-    /** Uncontrolled persistence, e.g. `expo-secure-store` or `AsyncStorage`. */
-    storage?: ColorModeStorage;
-    storageKey?: string;
-};
-export type UseThemedResult<S extends ThemedSchema = LooseSchema> = {
-    themed: ThemedStyles<S>;
-    /** Primitive, scheme-independent tokens exactly as in the config. */
-    tokens: S['tokens'];
-    /**
-     * Semantic tokens with colors (including text preset colors) resolved for
-     * the current scheme.
-     */
-    semanticTokens: S['semanticTokens'];
-    colorScheme: ColorScheme;
-};
-export type UseColorModeResult = {
-    mode: ColorMode;
-    setMode: (mode: ColorMode) => void;
-};
-/**
- * Binds a theme config to React: returns a provider plus hooks that read
- * the current scheme from it. Everything (store, contexts, precomputed
- * themes) is scoped to this call, so several instances can coexist.
- *
- * `S` is supplied by the generated `themed.gen.ts`
- * (`@react-native-rethemed/cli codegen`); without it tokens are loosely typed.
- */
-export declare function createThemed<S extends ThemedSchema = LooseSchema>(config: ThemeConfig): {
-    ThemedProvider: ({ children, colorScheme, defaultColorMode, storage, storageKey, }: ThemedProviderProps) => import("react").FunctionComponentElement<import("react").ProviderProps<ColorScheme | null>>;
-    useThemed: () => UseThemedResult<S>;
-    useColorMode: () => UseColorModeResult;
-};

package/dist/esm/create-themed.js

@@ -1,115 +0,0 @@
-import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useSyncExternalStore, } from 'react';
-import { Appearance, useColorScheme } from 'react-native';
-import { createColorModeStore, } from './color-mode-store.js';
-import { createThemedStyles } from './create-themed-styles.js';
-import { resolveSemanticColors, } from './resolvers/color-resolver.js';
-import { resolveTextTree } from './text-tree.js';
-const DEFAULT_STORAGE_KEY = 'react-native-rethemed.color-mode';
-/** RN 0.86 reports `'unspecified'` (and may report `null`); the theme is binary. */
-function toColorScheme(value) {
-    return value === 'dark' ? 'dark' : 'light';
-}
-/** `Appearance.setColorScheme` is RN 0.73+ only and absent on react-native-web. */
-function syncNativeAppearance(mode) {
-    if (typeof Appearance?.setColorScheme !== 'function')
-        return;
-    Appearance.setColorScheme(mode === 'system' ? 'unspecified' : mode);
-}
-const warnControlledSetMode = () => {
-    if (__DEV__) {
-        console.warn('[react-native-rethemed] setMode() was called while <ThemedProvider> is ' +
-            'controlled via the `colorScheme` prop. Update that prop instead.');
-    }
-};
-/**
- * Binds a theme config to React: returns a provider plus hooks that read
- * the current scheme from it. Everything (store, contexts, precomputed
- * themes) is scoped to this call, so several instances can coexist.
- *
- * `S` is supplied by the generated `themed.gen.ts`
- * (`@react-native-rethemed/cli codegen`); without it tokens are loosely typed.
- */
-export function createThemed(config) {
-    // Precomputed once per scheme so `useThemed()` returns referentially
-    // stable objects until the scheme actually changes.
-    const build = (colorScheme) => ({
-        themed: createThemedStyles(config, colorScheme),
-        tokens: config.tokens ?? {},
-        semanticTokens: {
-            colors: resolveSemanticColors(config, colorScheme),
-            text: resolveTextTree(config.semanticTokens?.text, colorScheme),
-        },
-        colorScheme,
-    });
-    const themes = {
-        light: build('light'),
-        dark: build('dark'),
-    };
-    const store = createColorModeStore();
-    // Split so a mode change that keeps the same scheme (e.g. 'system' ->
-    // 'light' while the OS is light) doesn't re-render `useThemed` consumers.
-    const SchemeContext = createContext(null);
-    const ModeContext = createContext(null);
-    function ThemedProvider({ children, colorScheme, defaultColorMode = 'system', storage, storageKey = DEFAULT_STORAGE_KEY, }) {
-        const isControlled = colorScheme !== undefined;
-        // Hooks run unconditionally so switching between controlled and
-        // uncontrolled never changes hook order or remounts children.
-        store.init(defaultColorMode);
-        const storedMode = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-        const systemScheme = toColorScheme(useColorScheme());
-        useEffect(() => {
-            if (isControlled || !storage || !store.beginHydration())
-                return;
-            // The store outlives this provider, so the result is applied even if
-            // it resolves after unmount; `hydrate` drops it if the user already
-            // picked a mode. `Promise.resolve().then` also catches a sync throw.
-            Promise.resolve()
-                .then(() => storage.getItem(storageKey))
-                .then((saved) => store.hydrate(saved))
-                .catch(() => { });
-        }, [isControlled, storage, storageKey]);
-        useEffect(() => {
-            if (!isControlled)
-                syncNativeAppearance(storedMode);
-        }, [isControlled, storedMode]);
-        const setUncontrolledMode = useCallback((next) => {
-            // Sync first: when returning to 'system', RN's `useColorScheme()`
-            // keeps reporting the old override until it's reset.
-            syncNativeAppearance(next);
-            store.setMode(next);
-            if (storage) {
-                Promise.resolve()
-                    .then(() => storage.setItem(storageKey, next))
-                    .catch(() => { });
-            }
-        }, [storage, storageKey]);
-        const scheme = isControlled
-            ? colorScheme
-            : storedMode === 'system'
-                ? systemScheme
-                : storedMode;
-        const mode = isControlled ? colorScheme : storedMode;
-        const setMode = isControlled ? warnControlledSetMode : setUncontrolledMode;
-        const modeValue = useMemo(() => ({ mode, setMode }), [mode, setMode]);
-        // `createElement` instead of JSX so consumers type-checking this source
-        // (it ships as `.ts`) don't need a `jsx` compiler option.
-        return createElement(SchemeContext, { value: scheme }, createElement(ModeContext, { value: modeValue }, children));
-    }
-    function useThemed() {
-        const scheme = useContext(SchemeContext);
-        if (scheme === null) {
-            throw new Error('useThemed() must be used within a <ThemedProvider> returned by the ' +
-                'same createThemed() call.');
-        }
-        return themes[scheme];
-    }
-    function useColorMode() {
-        const value = useContext(ModeContext);
-        if (value === null) {
-            throw new Error('useColorMode() must be used within a <ThemedProvider> returned by ' +
-                'the same createThemed() call.');
-        }
-        return value;
-    }
-    return { ThemedProvider, useThemed, useColorMode };
-}

package/dist/esm/define-theme.js

@@ -1,12 +0,0 @@
-/**
- * Identity function used purely as a type gate: checks `config` against
- * `ThemeConfig` (object literals get the usual excess-property check, so a
- * misspelled `radius` or `semanticToken` fails to compile).
- *
- * The return type is deliberately the plain `ThemeConfig` — exact token
- * names come from the generated `themed.gen.ts`, not from literal-type
- * inference here.
- */
-export function defineTheme(config) {
-    return config;
-}

package/dist/esm/extend-theme.js

@@ -1,115 +0,0 @@
-import { isSchemeColor } from './semantic-colors.js';
-import { isTextPreset } from './text-tree.js';
-/**
- * Flat `tokens` categories: a one-level merge (`{ ...a, ...b }`, `b` wins per
- * key) is enough. `semanticTokens.colors` holds groups (merged one level
- * deeper) and top-level colors (replaced whole); `semanticTokens.text` is a tree of any depth — see
- * `mergeTextTree`.
- *
- * Merging is runtime-only: the result is typed as the plain `ThemeConfig`,
- * and exact token names come from the generated `themed.gen.ts`.
- */
-const FLAT_CATEGORY_KEYS = [
-    'colors',
-    'radii',
-    'spacing',
-    'fontSizes',
-    'fontWeights',
-    'lineHeights',
-    'letterSpacings',
-    'zIndices',
-    'shadows',
-];
-function mergeFlat(a, b) {
-    if (!a)
-        return b;
-    if (!b)
-        return a;
-    return { ...a, ...b };
-}
-/**
- * `semanticTokens.colors`: groups are merged, colors replaced whole, so
- * overriding `bg.default` keeps `bg.subtle` and every other group. A
- * top-level color (`primary`) is replaced like a token; when a name is a
- * color on one side and a group on the other, the later side replaces it.
- */
-function mergeSemanticColors(a, b) {
-    if (!a)
-        return b;
-    if (!b)
-        return a;
-    const result = { ...a };
-    for (const [key, next] of Object.entries(b)) {
-        const prev = result[key];
-        result[key] =
-            prev && !isSchemeColor(prev) && !isSchemeColor(next)
-                ? { ...prev, ...next }
-                : next;
-    }
-    return result;
-}
-/**
- * `semanticTokens.text`: groups merge recursively, presets (leaves) are
- * replaced whole. So overriding `display.lg` keeps `display.md` and every
- * other group, at any depth. When a key is a preset on one side and a group
- * on the other, the later side replaces it.
- */
-function mergeTextTree(a, b) {
-    if (!a)
-        return b;
-    if (!b)
-        return a;
-    const result = { ...a };
-    for (const [key, next] of Object.entries(b)) {
-        const prev = result[key];
-        result[key] =
-            prev && !isTextPreset(prev) && !isTextPreset(next)
-                ? (mergeTextTree(prev, next) ?? next)
-                : next;
-    }
-    return result;
-}
-function mergeTokens(a, b) {
-    if (!a)
-        return b;
-    if (!b)
-        return a;
-    const merged = {};
-    for (const key of FLAT_CATEGORY_KEYS) {
-        const value = mergeFlat(a[key], b[key]);
-        if (value)
-            merged[key] = value;
-    }
-    return merged;
-}
-function mergeSemanticTokens(a, b) {
-    const colors = mergeSemanticColors(a?.colors, b?.colors);
-    const text = mergeTextTree(a?.text, b?.text);
-    return {
-        ...(colors ? { colors } : {}),
-        ...(text ? { text } : {}),
-    };
-}
-function mergeThemeConfig(a, b) {
-    const defaults = mergeFlat(a.defaults, b.defaults);
-    return {
-        tokens: mergeTokens(a.tokens, b.tokens),
-        semanticTokens: mergeSemanticTokens(a.semanticTokens, b.semanticTokens),
-        ...(defaults ? { defaults } : {}),
-    };
-}
-/**
- * Merges N `ThemeConfig`s, folding left-to-right so later themes override
- * earlier ones per key:
- *
- * ```ts
- * const config = extendTheme(materialDesignTheme, chakraUiTheme, {
- *   semanticTokens: {
- *     text: { display: { lg: { fontSize: 60, lineHeight: 68 } } },
- *   },
- * });
- * ```
- */
-export function extendTheme(...themes) {
-    return themes.reduce(mergeThemeConfig);
-}

package/dist/esm/index.d.ts

@@ -1,4 +0,0 @@
-export * from './config.js';
-export type { ColorMode, ColorModeStorage, ColorScheme, ThemedProviderProps, UseColorModeResult, UseThemedResult, } from './create-themed.js';
-export { createThemed } from './create-themed.js';
-export { createThemedStyles } from './create-themed-styles.js';

package/dist/esm/index.js

@@ -1,3 +0,0 @@
-export * from './config.js';
-export { createThemed } from './create-themed.js';
-export { createThemedStyles } from './create-themed-styles.js';

package/dist/esm/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/esm/resolvers/color-resolver.d.ts

@@ -1,10 +0,0 @@
-import type { ThemeConfig } from '../types.js';
-export type ColorScheme = 'light' | 'dark';
-/**
- * `config.semanticTokens.colors` for one scheme, keeping its shape: groups
- * become group -> token -> string (`{ fg: { default: '#000' } }`) and
- * top-level colors a string (`{ primary: '#171717' }`). Semantic values are
- * already concrete strings in the config, so this only picks
- * `light`/`dark`.
- */
-export declare function resolveSemanticColors(config: ThemeConfig, scheme: ColorScheme): Record<string, string | Record<string, string>>;

package/dist/esm/resolvers/color-resolver.js

@@ -1,23 +0,0 @@
-import { walkSemanticColors } from '../semantic-colors.js';
-/**
- * `config.semanticTokens.colors` for one scheme, keeping its shape: groups
- * become group -> token -> string (`{ fg: { default: '#000' } }`) and
- * top-level colors a string (`{ primary: '#171717' }`). Semantic values are
- * already concrete strings in the config, so this only picks
- * `light`/`dark`.
- */
-export function resolveSemanticColors(config, scheme) {
-    const result = {};
-    walkSemanticColors(config.semanticTokens?.colors, (token, color, group) => {
-        if (group === undefined) {
-            result[token] = color[scheme];
-        }
-        else {
-            if (result[group] === undefined)
-                result[group] = {};
-            const tokens = result[group];
-            tokens[token.slice(group.length + 1)] = color[scheme];
-        }
-    });
-    return result;
-}

package/dist/esm/resolvers/line-height-resolver.js

@@ -1,16 +0,0 @@
-/** React Native's own default `fontSize`. */
-export const RN_DEFAULT_FONT_SIZE = 14;
-/**
- * `defaults.fontSize` as a number: a `tokens.fontSizes` key is looked up,
- * a raw number is used as-is, anything else falls back to RN's default.
- */
-export function resolveBaseFontSize(config) {
-    const base = config.defaults?.fontSize;
-    if (typeof base === 'number')
-        return base;
-    const scale = config.tokens?.fontSizes;
-    if (typeof base === 'string' && scale && Object.hasOwn(scale, base)) {
-        return scale[base];
-    }
-    return RN_DEFAULT_FONT_SIZE;
-}

package/dist/esm/resolvers/style-resolver.d.ts

@@ -1,21 +0,0 @@
-import type { ThemeConfig } from '../types.js';
-import type { ColorScheme } from './color-resolver.js';
-/**
- * Builds the resolver behind `themed.view()` / `text()` / `image()` for one
- * color scheme.
- *
- * Everything that doesn't depend on the input is done once here: a single
- * **prop → token table** lookup (`backgroundColor` → the primitive
- * `tokens.colors` plus the flattened `'group.token'` semantic colors for this
- * scheme, `padding` → `tokens.spacing`, …).
- * Each call then makes **one pass over the input's own keys** (usually a
- * handful), rather than scanning every token-aware prop name, and copies the
- * input at most once — or not at all when nothing is a token.
- *
- * Two props need the rest of the style, so they are applied after the pass:
- * - `lineHeight` tokens are ratios of the (resolved) `fontSize`, falling back
- *   to `defaults.fontSize`;
- * - the virtual `shadow` prop expands last, so a preset wins over explicit
- *   `shadow*` props, and the `shadow` key itself is removed.
- */
-export declare function createStyleResolver(config: ThemeConfig, scheme: ColorScheme): (input: object) => Record<string, unknown>;

package/dist/esm/resolvers/style-resolver.js

@@ -1,101 +0,0 @@
-import { walkSemanticColors } from '../semantic-colors.js';
-import { COLOR_KEYS, FONT_SIZE_KEYS, FONT_WEIGHT_KEYS, LETTER_SPACING_KEYS, RADIUS_KEYS, SPACING_KEYS, Z_INDEX_KEYS, } from '../style-props.js';
-import { resolveBaseFontSize } from './line-height-resolver.js';
-/** Avoids float noise like `17.600000000000001` without pixel-snapping. */
-const round2 = (value) => Math.round(value * 100) / 100;
-const hasToken = (table, value) => (typeof value === 'string' || typeof value === 'number') &&
-    Object.hasOwn(table, value);
-/**
- * Builds the resolver behind `themed.view()` / `text()` / `image()` for one
- * color scheme.
- *
- * Everything that doesn't depend on the input is done once here: a single
- * **prop → token table** lookup (`backgroundColor` → the primitive
- * `tokens.colors` plus the flattened `'group.token'` semantic colors for this
- * scheme, `padding` → `tokens.spacing`, …).
- * Each call then makes **one pass over the input's own keys** (usually a
- * handful), rather than scanning every token-aware prop name, and copies the
- * input at most once — or not at all when nothing is a token.
- *
- * Two props need the rest of the style, so they are applied after the pass:
- * - `lineHeight` tokens are ratios of the (resolved) `fontSize`, falling back
- *   to `defaults.fontSize`;
- * - the virtual `shadow` prop expands last, so a preset wins over explicit
- *   `shadow*` props, and the `shadow` key itself is removed.
- */
-export function createStyleResolver(config, scheme) {
-    const tokens = config.tokens ?? {};
-    const byProp = Object.create(null);
-    const register = (props, table) => {
-        if (!table)
-            return;
-        for (const prop of props)
-            byProp[prop] = table;
-    };
-    // Color props take both kinds of color token. Primitives (`'red.500'`)
-    // go in first, so a semantic color with the same name wins (the CLI warns
-    // about such collisions).
-    const colors = { ...tokens.colors };
-    walkSemanticColors(config.semanticTokens?.colors, (token, color) => {
-        colors[token] = color[scheme];
-    });
-    if (tokens.colors || config.semanticTokens?.colors) {
-        register(COLOR_KEYS, colors);
-    }
-    register(RADIUS_KEYS, tokens.radii);
-    register(SPACING_KEYS, tokens.spacing);
-    register(FONT_SIZE_KEYS, tokens.fontSizes);
-    register(FONT_WEIGHT_KEYS, tokens.fontWeights);
-    register(LETTER_SPACING_KEYS, tokens.letterSpacings);
-    register(Z_INDEX_KEYS, tokens.zIndices);
-    const lineHeights = tokens.lineHeights;
-    const shadows = tokens.shadows;
-    const baseFontSize = resolveBaseFontSize(config);
-    return function resolveStyle(input) {
-        const source = input;
-        let result = null;
-        let lineHeightRatio;
-        let shadowPreset;
-        let hasShadow = false;
-        for (const key in source) {
-            const value = source[key];
-            if (key === 'lineHeight') {
-                if (lineHeights && hasToken(lineHeights, value)) {
-                    lineHeightRatio = lineHeights[value];
-                }
-                continue;
-            }
-            if (key === 'shadow') {
-                if (shadows) {
-                    hasShadow = true;
-                    shadowPreset = hasToken(shadows, value)
-                        ? shadows[value]
-                        : undefined;
-                }
-                continue;
-            }
-            const table = byProp[key];
-            if (table === undefined || !hasToken(table, value))
-                continue;
-            result ??= { ...source };
-            result[key] = table[value];
-        }
-        if (lineHeightRatio !== undefined) {
-            result ??= { ...source };
-            const fontSize = typeof result.fontSize === 'number' ? result.fontSize : baseFontSize;
-            result.lineHeight = round2(fontSize * lineHeightRatio);
-        }
-        if (hasShadow) {
-            // Rebuild without `shadow` instead of `delete`, which would push the
-            // object into V8/Hermes' slow dictionary mode.
-            const base = result ?? source;
-            const expanded = {};
-            for (const key in base) {
-                if (key !== 'shadow')
-                    expanded[key] = base[key];
-            }
-            result = shadowPreset ? Object.assign(expanded, shadowPreset) : expanded;
-        }
-        return result ?? source;
-    };
-}

package/dist/esm/semantic-colors.js

@@ -1,28 +0,0 @@
-/**
- * A color of `semanticTokens.colors` (as opposed to a group of them): an
- * object whose `light` or `dark` is a string. A group's values are objects,
- * so a group may still name a token `light` or `dark` (Material UI's
- * `primary.light`).
- */
-export function isSchemeColor(node) {
-    if (typeof node !== 'object' || node === null)
-        return false;
-    const { light, dark } = node;
-    return typeof light === 'string' || typeof dark === 'string';
-}
-/**
- * Visits every semantic color in definition order with its token name:
- * `'group.token'` inside a group, or the bare name for a top-level color
- * (`'primary'`, `'primary-foreground'`).
- */
-export function walkSemanticColors(colors, visit) {
-    for (const [key, node] of Object.entries(colors ?? {})) {
-        if (isSchemeColor(node)) {
-            visit(key, node, undefined);
-            continue;
-        }
-        for (const [name, color] of Object.entries(node)) {
-            visit(`${key}.${name}`, color, key);
-        }
-    }
-}