@stacksjs/ts-css 0.1.4 → 0.3.2

package/dist/engine/style/registry.d.ts

@@ -0,0 +1,56 @@
+/** Serialises everything `css.create()` and friends have registered so far. */
+export declare function renderStyles(minify?: boolean): string;
+/** Empties the registry. Tests and watch-mode rebuilds need this. */
+export declare function resetStyles(): void;
+/** How many distinct atomic classes exist right now. */
+export declare function styleCount(): number;
+/**
+ * Increments every time the registry is cleared.
+ *
+ * Rules are registered as a side effect of module evaluation, and a module
+ * only evaluates once per specifier — so after a reset the modules that
+ * declared those rules would stay cached and never re-register them. Folding
+ * this counter into the import specifier makes a reset genuinely start over.
+ */
+export declare function styleGeneration(): number;
+export declare const registry: StyleRegistry;
+/**
+ * One atomic declaration: a single property/value pair under a fixed chain of
+ * conditions, owning exactly one class name.
+ */
+export declare interface AtomicRule {
+  className: string
+  property: string
+  values: string[]
+  conditions: string[]
+  priority: number
+}
+/** A `@keyframes` block keyed by its generated animation name. */
+export declare interface KeyframesRule {
+  name: string
+  css: string
+}
+/** A custom-property definition, optionally scoped to a selector/at-rule. */
+export declare interface VarRule {
+  selector: string
+  atRule?: string
+  declarations: Record<string, string>
+}
+/**
+ * Process-wide store of everything the style API has generated.
+ *
+ * `css.create()` registers as a side effect of module evaluation, which is
+ * what lets the build collect styles by simply importing the modules that
+ * declare them — no AST pass, and no chance of the emitted CSS disagreeing
+ * with the class names the app actually renders.
+ */
+declare class StyleRegistry {
+  addRule(rule: AtomicRule): void;
+  addKeyframes(rule: KeyframesRule): void;
+  addVars(rule: VarRule): void;
+  has(className: string): boolean;
+  get size(): number;
+  clear(): void;
+  get currentGeneration(): number;
+  toCSS(minify?: boolean): string;
+}

package/dist/engine/style/types.d.ts

@@ -0,0 +1,54 @@
+/** Marks the tuple a dynamic style returns, so `props` never mistakes it for a list. */
+export declare const DYNAMIC_STYLE: unique symbol;
+/**
+ * A style object. Keys are camelCase CSS properties; keys starting with `:`,
+ * `::` or `@`, or containing `&`, open a nested condition instead.
+ *
+ * A property may also map to an object of conditions:
+ * `{ color: { default: 'blue', ':hover': 'red' } }`.
+ */
+export declare interface StyleRule {
+  [key: string]: StyleValue | StyleRule
+}
+/** The compiled form of one named style: merge key -> class name. */
+export declare interface CompiledStyle {
+  readonly [key: string]: string | null
+}
+/** What `css.props()` spreads onto an element. */
+export declare interface StyleProps {
+  className?: string
+  style?: Record<string, string>
+}
+/** A `@keyframes` body: percentage/`from`/`to` keys mapping to style objects. */
+export declare interface KeyframeDefinition {
+  [step: string]: StyleRule
+}
+/**
+ * Public types for the style object API.
+ */
+/** A single declaration's value. `null` explicitly unsets an inherited style. */
+export type StyleValue = string | number | null | undefined | readonly (string | number)[];
+/** A compiled style plus the inline custom properties that parameterise it. */
+export type DynamicStyle = readonly [CompiledStyle, Readonly<Record<string, string>>] & {
+  readonly [DYNAMIC_STYLE]?: true
+}
+/** Anything `css.props()` accepts. Falsy entries are skipped. */
+export type StyleArg = | CompiledStyle
+  | DynamicStyle
+  | false
+  | null
+  | undefined
+  | readonly StyleArg[];
+// `_args` only names the tuple that `A` is inferred from — matching the
+// `_match` convention the `CustomRule` signature already uses.
+export type CompiledOf<T> = T extends (..._args: infer A) => any
+  ? (..._args: A) => DynamicStyle
+  : CompiledStyle;
+/** The map `css.create()` hands back, one entry per named style. */
+export type CreatedStyles<T> = { readonly [K in keyof T]: CompiledOf<T[K]> }
+/** A variable group's value: a plain value, or per-condition values. */
+export type VarValue = | string
+  | number
+  | { default: string | number, [condition: string]: string | number }
+/** What `css.defineVars()` returns — every key is a ready-to-use `var(…)`. */
+export type VarGroup<T> = { readonly [K in keyof T]: string }

package/dist/engine/style/value.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `backgroundColor` -> `background-color`, `WebkitLineClamp` ->
+ * `-webkit-line-clamp`. Custom properties (`--brand`) pass through untouched.
+ */
+export declare function toKebabCase(property: string): string;
+/**
+ * Numbers become `px` unless the property is unitless or the value is zero.
+ * Everything else is stringified as-is.
+ */
+export declare function normalizeValue(property: string, value: string | number): string;
+/**
+ * Renders one declaration's value. Arrays become CSS fallbacks — the caller
+ * emits one declaration per entry, in order, so the last supported one wins.
+ */
+export declare function normalizeValues(property: string, value: string | number | readonly (string | number)[]): string[];

package/dist/engine/transformer-compile-class.d.ts

@@ -0,0 +1,34 @@
+import type { CssConfig } from './types';
+/**
+ * Extract compile class markers from content
+*/
+export declare function extractCompileClasses(content: string, options?: CompileClassOptions): Map<string, string[]>;
+/**
+ * Transform content by replacing compile markers with generated class names
+*/
+export declare function transformContent(content: string, compiledClassMap: Map<string, string>, options?: CompileClassOptions): string;
+/**
+ * Generate class names for compiled classes
+*/
+export declare function generateCompiledClassNames(compiledClasses: Map<string, string[]>, options?: CompileClassOptions): Map<string, string>;
+export declare interface CompileClassOptions {
+  trigger?: string
+  classPrefix?: string
+  hashFn?: (content: string) => string
+  layer?: string
+}
+/**
+ * Main transformer class
+*/
+export declare class CompileClassTransformer {
+  constructor(options?: CompileClassOptions);
+  processFile(content: string): { content: string, hasChanges: boolean };
+  getCompiledClasses(): Map<string, { className: string, utilities: string[] }>;
+  generateCSS(config: CssConfig, generator: any): string;
+  reset(): void;
+  getStats(): {
+    totalGroups: number
+    totalUtilities: number
+    averageUtilitiesPerGroup: number
+  };
+}

package/dist/engine/types.d.ts

@@ -0,0 +1,156 @@
+import type { CodeStringsConfig } from './parser';
+export declare interface CompileClassConfig {
+  enabled?: boolean
+  trigger?: string
+  classPrefix?: string
+  layer?: string
+}
+export declare interface AttributifyConfig {
+  enabled?: boolean
+  prefix?: string
+  ignoreAttributes?: string[]
+}
+export declare interface BracketSyntaxConfig {
+  enabled?: boolean
+  colonSyntax?: boolean
+  aliases?: Record<string, string>
+}
+/**
+ * Web-font loading. Crosswind maps `font-*` utilities to family stacks, but it
+ * never loaded the actual font files — declare them here and ts-css emits the
+ * `@import` / `@font-face` so the fonts render with zero extra wiring.
+ */
+export declare interface FontConfig {
+  google?: string[]
+  display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional'
+  faces?: string[]
+}
+export declare interface CssConfig {
+  content: string[]
+  output: string
+  minify: boolean
+  watch: boolean
+  verbose?: boolean
+  includePreflight?: boolean
+  darkMode?: 'class' | 'media'
+  theme: Theme
+  fonts?: FontConfig
+  shortcuts: Record<string, string | string[]>
+  rules: CustomRule[]
+  variants: VariantConfig
+  safelist: string[]
+  blocklist: string[]
+  preflights: Preflight[]
+  presets: Preset[]
+  compileClass?: CompileClassConfig
+  attributify?: AttributifyConfig
+  bracketSyntax?: BracketSyntaxConfig
+  codeStrings?: CodeStringsConfig
+  cssVariables?: boolean
+  styles?: string[]
+}
+export declare interface Theme {
+  colors: Record<string, string | Record<string, string>>
+  spacing: Record<string, string>
+  fontSize: Record<string, [string, { lineHeight: string }]>
+  fontFamily: Record<string, string[]>
+  lineHeight?: Record<string, string>
+  screens: Record<string, string>
+  borderRadius: Record<string, string>
+  boxShadow: Record<string, string>
+  extend?: Partial<Omit<Theme, 'extend'>>
+}
+export declare interface VariantConfig {
+  'responsive': boolean
+  'hover': boolean
+  'focus': boolean
+  'active': boolean
+  'disabled': boolean
+  'dark': boolean
+  'light': boolean
+  'group': boolean
+  'peer': boolean
+  'before': boolean
+  'after': boolean
+  'marker': boolean
+  'first': boolean
+  'last': boolean
+  'odd': boolean
+  'even': boolean
+  'first-of-type': boolean
+  'last-of-type': boolean
+  'visited': boolean
+  'checked': boolean
+  'focus-within': boolean
+  'focus-visible': boolean
+  'placeholder': boolean
+  'selection': boolean
+  'file': boolean
+  'required': boolean
+  'valid': boolean
+  'invalid': boolean
+  'read-only': boolean
+  'autofill': boolean
+  'open': boolean
+  'closed': boolean
+  'empty': boolean
+  'enabled': boolean
+  'only': boolean
+  'target': boolean
+  'indeterminate': boolean
+  'default': boolean
+  'optional': boolean
+  'aria': boolean
+  'data': boolean
+  'has': boolean
+  'not': boolean
+  'supports': boolean
+  'print': boolean
+  'landscape': boolean
+  'portrait': boolean
+  'forced-colors': boolean
+  'rtl': boolean
+  'ltr': boolean
+  'motion-safe': boolean
+  'motion-reduce': boolean
+  'contrast-more': boolean
+  'contrast-less': boolean
+}
+export declare interface ParsedClass {
+  raw: string
+  base: string
+  variants: string[]
+  utility: string
+  value?: string
+  important: boolean
+  arbitrary: boolean
+  modifierArbitrary?: boolean
+  typeHint?: string
+}
+export declare interface CSSRule {
+  selector: string
+  properties: Record<string, string>
+  mediaQuery?: string
+  childSelector?: string
+}
+export declare interface UtilityRuleResult {
+  properties: Record<string, string>
+  childSelector?: string
+  pseudoElement?: string
+}
+export declare interface Preflight {
+  getCSS: () => string
+}
+export declare interface Preset {
+  name: string
+  theme?: Partial<Theme>
+  rules?: CustomRule[]
+  shortcuts?: Record<string, string | string[]>
+  variants?: Partial<VariantConfig>
+  preflights?: Preflight[]
+}
+export type CustomRule = [RegExp, (_match: RegExpMatchArray) => Record<string, string> | undefined];
+declare type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P]
+}
+export type CssOptions = DeepPartial<CssConfig>;