@ui0/theme 0.0.0-stage → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,339 @@
+import { InjectionKey, Ref } from "vue";
+import { ThemeProvider } from "./components/index.js";
+import { AnyProps, CSSModuleClassList, ClassList, ComponentColor, ComponentElevation, ComponentRound, ComponentRoundTarget, ContractProvider, ContractRefs, InheritValue, LiteralUnion, MaybeAngle, MaybePercents, MaybeUnits, Numberish, RgbTuple, StyleList, ThemeAppearance, ThemeContract, ThemeContractDeal, ThemeContractGenerator, ThemeContractGenerator as ThemeContractGenerator$1, ThemeContractName, ThemeContractName as ThemeContractName$1, ThemeInstance, ThemeInstance as ThemeInstance$1, ThemeInstanceOptions, ThemeInstanceOptions as ThemeInstanceOptions$1, ThemePluginConfig, ThemePluginConfig as ThemePluginConfig$1, ThemePreset, ThemePresetName, ThemePresetName as ThemePresetName$1, Ui0CoreInstallablePlugin, Ui0ThemeColorRef, Ui0ThemeContractSettings, Ui0ThemeContracts, Ui0ThemeContracts as Ui0ThemeContracts$1, Ui0ThemePresetAppearanceConfig, Ui0ThemePresetAppearanceConfig as Ui0ThemePresetAppearanceConfig$1, UpdateFn } from "@ui0/types";
+/** the backdrop-filter functions the backdrop prop selects from */
+type BackdropFunction = 'blur' | 'brightness' | 'contrast' | 'drop-shadow' | 'grayscale' | 'hue-rotate' | 'invert' | 'opacity' | 'saturate' | 'sepia';
+interface BackdropProps {
+  backdrop?: BackdropFunction | `${BackdropFunction}@${Numberish}`;
+}
+/** per-function default values the generator turns into setter classes */
+interface BackdropThemeAppearanceConfig {
+  blur?: MaybeUnits;
+  brightness?: MaybePercents;
+  contrast?: MaybePercents;
+  'drop-shadow'?: string;
+  grayscale?: MaybePercents;
+  'hue-rotate'?: MaybeAngle;
+  invert?: MaybePercents;
+  opacity?: MaybePercents;
+  saturate?: MaybePercents;
+  sepia?: MaybePercents;
+}
+declare module '@ui0/types/theme' {
+  interface Ui0ThemePresetAppearanceConfig {
+    backdrop?: BackdropThemeAppearanceConfig;
+  }
+  interface Ui0ThemeContracts extends BackdropProps {}
+  interface Ui0ThemeContractSettings {
+    /** `false` disables the contract entirely; otherwise per-function toggles */
+    backdrop?: false | Partial<Record<BackdropFunction, boolean>>;
+  }
+}
+/** the `color` prop: text/foreground paint. See color.token.ts for the dsl. */
+interface ColorProps {
+  color?: Ui0ThemeColorRef;
+}
+/** the `fill` prop: background paint. Same dsl as `color`. */
+interface FillProps {
+  fill?: Ui0ThemeColorRef;
+}
+/** the `gradient` prop: background-image linear-gradient composed from pool
+ * refs (`to-br error->success@80`). Resolved onto `--0-g-cur` as an
+ * inline style - see color.gradient.ts. */
+interface GradientProps {
+  gradient?: Ui0ThemeColorRef;
+}
+/** legacy alias kept for the package's public type exports */
+interface Gradientable {
+  color?: ComponentColor;
+}
+type ThemeColorName = string;
+type ThemeColorPool = Record<ThemeColorName, ThemeColorEntry>;
+/** the color contract's settings inside a theme preset (appearance config) -
+ * a flat pool: role/arbitrary name -> color entry (ramp expressions allowed) */
+type ColorThemeAppearanceConfig = ThemeColorPool;
+/** (l)ighten, (d)arken, (c)ontrast, (s)hade. */
+type ThemeColorRampType = 'l' | 'd' | 'c' | 's';
+/** Color space the ramp math runs in - perceptual `oklch` or legacy `hsl`. */
+type ThemeColorSpace = 'hsl' | 'oklch';
+interface ColorOptions {
+  ramps?: ThemeColorRampType[];
+  space?: ThemeColorSpace;
+}
+type ThemeColorBlendExpr = [string | RgbTuple, string | RgbTuple, number];
+type ThemeColorRef = string;
+type ThemeColorEntry = ThemeColorRef | [ThemeColorRef | ThemeColorBlendExpr, number, (ThemeColorRampType[] | ColorOptions)?];
+/** consumer-side color contract settings (ThemePluginConfig.contracts.color) */
+type ColorScheme = 'light' | 'dark';
+type ColorPseudo = 'hover' | 'active' | 'focus';
+interface ColorToken {
+  scheme?: ColorScheme;
+  pseudo?: ColorPseudo;
+  /** pool reference: `name` or `name-{l|d|c|s}{step}` */
+  ref: string;
+  /** 0..1; undefined = fully opaque */
+  opacity?: number;
+}
+declare module '@ui0/types/theme' {
+  interface Ui0ThemePresetAppearanceConfig {
+    color?: ColorThemeAppearanceConfig;
+  }
+  interface Ui0ThemeContractSettings {
+    /** `false` (or `true`) toggles the contract wholesale; an object is
+     * reserved for color contract options (none yet) */
+    color?: boolean | Record<string, unknown>;
+  }
+  interface Ui0ThemeContracts extends ColorProps, FillProps, GradientProps {}
+}
+interface DisabledProps {
+  disabled?: boolean;
+}
+interface DisabledThemeAppearanceConfig {
+  opacity?: number;
+}
+declare module '@ui0/types/theme' {
+  interface Ui0ThemePresetAppearanceConfig {
+    disabled?: DisabledThemeAppearanceConfig;
+  }
+  interface Ui0ThemeContractSettings {
+    disabled?: boolean;
+  }
+  interface Ui0ThemeContracts extends DisabledProps {}
+}
+interface ElevationProps {
+  elevation?: ComponentElevation;
+}
+interface ElevationThemeAppearanceConfig {
+  steps?: number;
+}
+declare module '@ui0/types/theme' {
+  interface Ui0ThemePresetAppearanceConfig {
+    elevation?: ElevationThemeAppearanceConfig;
+  }
+  interface Ui0ThemeContractSettings {
+    elevation?: boolean;
+  }
+  interface Ui0ThemeContracts extends ElevationProps {}
+}
+interface RoundProps {
+  round?: Round;
+  roundTarget?: RoundTarget;
+}
+interface RoundThemeAppearanceConfig {
+  rounding: 'relative' | 'static';
+}
+declare module '@ui0/types/theme' {
+  interface Ui0ThemePresetAppearanceConfig {
+    round?: RoundThemeAppearanceConfig;
+  }
+  interface Ui0ThemeContractSettings {
+    round?: {
+      rounding: 'relative' | 'static';
+    };
+  }
+  interface Ui0ThemeContracts extends RoundProps {}
+}
+type RoundTarget = InheritValue | 'top' | 'bottom' | 'left' | 'right' | 'top-none' | 'bottom-none' | 'left-none' | 'right-none' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-left-none' | 'top-right-none' | 'bottom-left-none' | 'bottom-right-none';
+type Round = LiteralUnion<InheritValue | 'basic' | 'full' | 'none' | 'hard' | 'smooth'>;
+type SizeXXXS = 'xxx-small' | 'xxxs';
+type SizeXXS = 'xx-small' | 'xxs';
+type SizeXS = 'x-small' | 'xs';
+type SizeS = 'small' | 's';
+type SizeM = 'medium' | 'm';
+type SizeL = 'large' | 'l';
+type SizeXL = 'x-large' | 'xl';
+type SizeXXL = 'xx-large' | 'xxl';
+type SizeXXXL = 'xxx-large' | 'xxxl';
+type Size = SizeXXXS | SizeXXS | SizeXS | SizeS | SizeM | SizeL | SizeXL | SizeXXL | SizeXXXL | 'custom' | 'smaller' | 'larger' | InheritValue;
+type SizeDensity = LiteralUnion<'normal' | 'compact' | 'child'>;
+interface SizeProps {
+  size?: Size;
+}
+interface DensityProps {
+  density?: SizeDensity;
+}
+/** the size contract's settings inside a theme preset (appearance config) */
+interface SizeThemeAppearanceConfig {
+  /** the control's base height -> expands into the --0-s-* scale */
+  control?: MaybeUnits;
+  /** a control's child (icon etc.) base height -> the --0-sc-* scale */
+  child?: MaybeUnits;
+}
+/** the absolute scale steps a `size` prop can pick (long and short spellings) */
+declare const SizeValuesAbsolute: Size[];
+declare module '@ui0/types/theme' {
+  interface Ui0ThemePresetAppearanceConfig {
+    size?: SizeThemeAppearanceConfig;
+  }
+  interface Ui0ThemeContractSettings {
+    size?: boolean;
+  }
+  interface Ui0ThemeContracts extends SizeProps, DensityProps {}
+}
+/**
+ * Merge the built-in default preset UNDER every preset of the consumer's
+ * config (weakest -> strongest: built-in default <- the preset itself), so
+ * any setting a preset omits falls back to the default. The default preset
+ * itself is always present; an empty consumer config gets exactly the
+ * built-in default. Contract settings follow the same rule - the built-in
+ * `contracts` map sits under the consumer's one (deep-merged per contract).
+ */
+export declare function withDefaults(config?: ThemePluginConfig$1): ThemePluginConfig$1;
+/**
+ * The structural result of a generation run: the theme css (preset blocks +
+ * contract setter classes inside `@layer theme`) plus each contract's css
+ * keyed by name - a consumer that wants to split outputs takes the pieces
+ * apart instead of the single {@link generateThemeCss} string.
+ */
+interface ThemeArtifacts {
+  themeCss: string;
+  contractCss: Record<string, string>;
+  /** per-contract consumer scss (localScss), first preset wins - config-independent */
+  localScss: Record<string, string>;
+}
+/**
+ * Generate the theme for a resolved config: one base block per preset
+ * (`.theme-{preset}`) plus a scheme block per declared appearance
+ * (`.theme_{scheme}`, re-declaring the full merged config), and every
+ * contract's setter classes, deduped across presets, inside `@layer theme`.
+ *
+ * @param config - a config already passed through {@link withDefaults}
+ * @param emitPresets - which presets get a css block. Defaults to every
+ *   preset of `config`; pass the consumer's own preset names to keep the
+ *   built-in default out of the emitted css while it still back-fills the
+ *   consumer's presets with fallback values
+ * @returns the assembled theme css and the per-contract css/scss pieces
+ */
+export declare function generateThemeArtifacts(config: ThemePluginConfig$1, emitPresets?: ThemePresetName$1[]): ThemeArtifacts;
+/**
+ * Generate the complete theme CSS for a resolved config - the single-string
+ * form of {@link generateThemeArtifacts}. Pass the result through
+ * `withDefaults` first unless the config is already self-complete.
+ *
+ * @param config - a config already passed through {@link withDefaults}
+ * @param emitPresets - which presets get a css block (see
+ *   {@link generateThemeArtifacts})
+ * @returns the theme css (preset + scheme blocks + setter classes)
+ */
+export declare function generateThemeCss(config: ThemePluginConfig$1, emitPresets?: ThemePresetName$1[]): string;
+/**
+ * Generate a .d.ts that augments the global Ui0Theme* registries so the
+ * editor can suggest what exists: Ui0ThemeNames (presets for ThemeProvider),
+ * Ui0ThemeSchemeNames (appearances), Ui0ThemeColorNames (pool refs incl.
+ * ramp steps, unioned across every emitted preset and scheme). Pass
+ * withDefaults(config).
+ *
+ * @param config - a config already passed through {@link withDefaults}
+ * @param emitPresets - which presets contribute names (see
+ *   {@link generateThemeArtifacts}); defaults to every preset of `config`
+ */
+export declare function generateThemeTypes(config: ThemePluginConfig$1, emitPresets?: ThemePresetName$1[]): string;
+export declare function createUi0Theme(config: ThemePluginConfig$1): Ui0CoreInstallablePlugin;
+export declare function createThemeInstance(config: ThemePluginConfig$1, options?: ThemeInstanceOptions$1): ThemeInstance$1;
+export declare function useTheme(): ThemeInstance$1 | undefined;
+type DisplayMeasure = 'width' | 'height';
+type DisplayBreakpoint = string | 'xxs' | 's' | 'xs' | 'xxl' | 'lg' | 'xl' | 'hd' | 'fhd' | 'qhd' | 'uhd';
+type DisplayBreakpoints = Record<DisplayBreakpoint, Numberish>;
+interface DisplayProps {}
+interface DisplayThemeAppearanceConfig {
+  /** e.g. a base value the generator emits as a css var */
+  base?: MaybeUnits;
+}
+declare module '@ui0/types/theme' {
+  interface Ui0ThemePresetAppearanceConfig {
+    display?: DisplayThemeAppearanceConfig;
+  }
+  interface Ui0ThemeContractSettings {
+    display?: {
+      breakpoints: DisplayBreakpoints;
+    };
+  }
+  interface Ui0ThemeContracts extends DisplayProps {}
+}
+interface DisplayReturn {
+  breakpoints: DisplayBreakpoints;
+  between: (point: DisplayBreakpoint, b: DisplayBreakpoint, measure?: DisplayMeasure) => Ref<boolean>;
+  greater: (point: DisplayBreakpoint, measure?: DisplayMeasure) => Ref<boolean>;
+  less: (point: DisplayBreakpoint, measure?: DisplayMeasure) => Ref<boolean>;
+}
+export declare function useDisplay(onUpdate?: UpdateFn): DisplayReturn;
+declare class ThemeContractInstance implements ContractProvider {
+  props: AnyProps;
+  /**
+   * context have any provided props from styler's
+   */
+  context: ContractRefs | null;
+  $styles: CSSModuleClassList;
+  name: string;
+  classList: ClassList;
+  styleList: StyleList;
+  contracts: Partial<Record<ThemeContractName$1, ThemeContract>>;
+  constructor(name: string, props?: Ui0ThemeContracts$1, styles?: CSSModuleClassList);
+  add(contract: ThemeContract): void;
+  prop(name: keyof Ui0ThemeContracts$1 | Array<keyof Ui0ThemeContracts$1>): {
+    styles(): StyleList;
+    classes(): ClassList;
+  };
+  remove(name: ThemeContractName$1): void;
+  setContext(p: ContractRefs): void;
+  classes(props_?: AnyProps, $styles?: CSSModuleClassList): ClassList;
+  styles(props_?: AnyProps): StyleList;
+  /**
+   * Virtual's classes and styles injector
+   * @param data
+   * @private
+   */
+  inject(data?: any): any;
+}
+export declare function useThemeContext(props: Ui0ThemeContracts$1, $styles?: CSSModuleClassList, _allowContracts?: Array<keyof Ui0ThemeContracts$1>): [ThemeInstance$1 | undefined, ThemeContractInstance | undefined];
+interface ContractContext {
+  /** the preset this generator instance is created for */
+  presetName: ThemePresetName$1;
+  /**
+   * the resolved appearance config (extends flattened, base merged under
+   * the scheme) the vars are generated from
+   */
+  config: Ui0ThemePresetAppearanceConfig$1;
+  /**
+   * the consumer-side contract settings (ThemePluginConfig.contracts) - a
+   * contract reads its own slice to toggle behavior preset-independently
+   * (e.g. which backdrop functions ship at all)
+   */
+  settings: Ui0ThemeContractSettings;
+  /** class-name hasher - the same algorithm the distiller hashes module.css with */
+  hash: (name: string) => string;
+}
+type ContractFactory = (ctx: ContractContext) => ThemeContractGenerator$1;
+export declare const contractGenerators: Record<string, ContractFactory>;
+declare const RoundRefKey: InjectionKey<Ref<ComponentRound>>;
+declare const RoundTargetRefKey: InjectionKey<Ref<ComponentRoundTarget>>;
+declare const RoundContractKey: InjectionKey<ThemeContractDeal>;
+declare const RoundPropsKeys: ReadonlyArray<keyof RoundProps>;
+declare const round: ThemeContract;
+declare const BackdropRefKey: InjectionKey<Ref<BackdropProps["backdrop"]>>;
+declare const BackdropContractKey: InjectionKey<ThemeContractDeal>;
+declare const BackdropPropsKeys: ReadonlyArray<keyof BackdropProps>;
+declare const backdrop: ThemeContract;
+declare const ColorContractKey: InjectionKey<ThemeContractDeal>;
+declare const ColorRefKey: InjectionKey<Ref<ComponentColor>>;
+declare const FillRefKey: InjectionKey<Ref<ComponentColor>>;
+declare const ColorPropsKeys: ReadonlyArray<keyof (GradientProps & ColorProps & FillProps)>;
+declare const color: ThemeContract;
+declare const DisabledRefKey: InjectionKey<Ref<boolean>>;
+declare const DisabledContractKey: InjectionKey<ThemeContractDeal>;
+declare const DisabledPropsKeys: ReadonlyArray<keyof DisabledProps>;
+declare const disabled: ThemeContract;
+declare const ElevationRefKey: InjectionKey<Ref<ComponentElevation>>;
+declare const ElevationContractKey: InjectionKey<ThemeContractDeal>;
+declare const ElevationPropsKeys: ReadonlyArray<keyof ElevationProps>;
+declare const elevation: ThemeContract;
+declare const SizeRefKey: InjectionKey<Ref<Size>>;
+declare const SizeDensityRefKey: InjectionKey<Ref<SizeDensity>>;
+declare const SizeContractKey: InjectionKey<ThemeContractDeal>;
+declare const sizeGenerator: ContractFactory;
+declare const SizePropsKeys: ReadonlyArray<keyof (SizeProps & DensityProps)>;
+declare const size: ThemeContract;
+declare const contracts: Record<ThemeContractName$1, ThemeContract>;
+declare const props: ("backdrop" | "color" | "disabled" | "elevation" | "size" | "gradient" | "fill" | keyof RoundProps | "density")[];
+export { type BackdropContractKey, type BackdropFunction, type BackdropProps, type BackdropPropsKeys, type BackdropRefKey, type BackdropThemeAppearanceConfig, type ColorContractKey, type ColorOptions, type ColorProps, type ColorPropsKeys, type ColorPseudo, type ColorRefKey, type ColorScheme, type ColorThemeAppearanceConfig, type ColorToken, type DensityProps, type DisabledContractKey, type DisabledProps, type DisabledPropsKeys, type DisabledRefKey, type DisabledThemeAppearanceConfig, type ElevationContractKey, type ElevationProps, type ElevationPropsKeys, type ElevationRefKey, type ElevationThemeAppearanceConfig, type FillProps, type FillRefKey, type GradientProps, type Gradientable, type Round, type RoundContractKey, type RoundProps, type RoundPropsKeys, type RoundRefKey, type RoundTarget, type RoundTargetRefKey, type RoundThemeAppearanceConfig, type Size, type SizeContractKey, type SizeDensity, type SizeDensityRefKey, type SizeL, type SizeM, type SizeProps, type SizePropsKeys, type SizeRefKey, type SizeS, type SizeThemeAppearanceConfig, type SizeValuesAbsolute, type SizeXL, type SizeXS, type SizeXXL, type SizeXXS, type SizeXXXL, type SizeXXXS, type ThemeAppearance, type ThemeColorBlendExpr, type ThemeColorEntry, type ThemeColorName, type ThemeColorPool, type ThemeColorRampType, type ThemeColorRef, type ThemeColorSpace, type ThemeContractGenerator, type ThemeContractName, props as ThemeContractPropsKeys, type props, type ThemeInstance, type ThemeInstanceOptions, type ThemePluginConfig, type ThemePreset, type ThemePresetName, ThemeProvider, type Ui0ThemeContracts, type Ui0ThemePresetAppearanceConfig, type backdrop, type color, type contracts, type disabled, type elevation, type round, type size, type sizeGenerator };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":["_0","_0","_0","_0","_0","_0","ThemePluginConfig","ThemePresetName","ThemePluginConfig","ThemePluginConfig","ThemeInstanceOptions","ThemeInstance","ThemeInstance","ThemeContractName","Ui0ThemeContracts","Ui0ThemeContracts","ThemeInstance","ThemePresetName","Ui0ThemePresetAppearanceConfig","ThemeContractGenerator","ThemeContractName","_$__round0.RoundProps"],"sources":["../src/contracts/backdrop/backdrop.types.ts","../src/contracts/color/color.types.ts","../src/contracts/disabled/disabled.types.ts","../src/contracts/elevation/elevation.types.ts","../src/contracts/round/round.types.ts","../src/contracts/size/size.types.ts","../src/generator/generate.ts","../src/plugin.ts","../src/instance.ts","../src/useTheme.ts","../src/contracts/display/display.types.ts","../src/useDisplay.ts","../src/contracts/contract.ts","../src/useThemeContext.ts","../src/contracts/generator.ts","../src/generator.ts","../src/contracts/round/round.keys.ts","../src/contracts/round/index.ts","../src/contracts/backdrop/backdrop.keys.ts","../src/contracts/backdrop/index.ts","../src/contracts/color/color.keys.ts","../src/contracts/color/index.ts","../src/contracts/disabled/disabled.keys.ts","../src/contracts/disabled/index.ts","../src/contracts/elevation/elevation.keys.ts","../src/contracts/elevation/index.ts","../src/contracts/size/size.keys.ts","../src/contracts/size/size.generator.ts","../src/contracts/size/index.ts","../src/contracts/index.ts"],"mappings":"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"}