@cassida/compiler 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Marker for arguments the parser could not statically evaluate. The
+ * parser stashes the original AST node behind `id`; the compiler treats
+ * these as opaque placeholders for canonical-key purposes and wires the
+ * surviving slot into the resulting `CompiledRule.dynamics` list.
+ */
+export declare const DYNAMIC_TAG = "__fss_dynamic__";
+export interface DynamicArg {
+    readonly [DYNAMIC_TAG]: true;
+    readonly id: string;
+}
+export declare function isDynamic(v: unknown): v is DynamicArg;
+/**
+ * Sentinel value placed in a property bag for slots whose value is
+ * dynamic. The choice of ` ` makes accidental collision with a
+ * real CSS string impossible.
+ */
+export declare const DYNAMIC_PLACEHOLDER = " <FSS_DYN> ";
+/**
+ * A method call captured from a `cas()` chain, e.g. `color('red')`.
+ */
+export interface MethodOp {
+    readonly method: string;
+    readonly args: readonly unknown[];
+}
+/**
+ * A scope-introducing call (`hover(c => ...)`, `media(q, c => ...)`,
+ * `on(sel, c => ...)`). Inner ops are collected from the callback's
+ * fresh chain and nested under this scope.
+ */
+export interface ScopedOp {
+    readonly scope: Scope;
+    readonly ops: readonly Op[];
+}
+/**
+ * A direct CSS property write that bypasses the registry — emitted
+ * by `fss.unsafe(preset)` for keys outside the safe canonical set.
+ *
+ * `property` is a kebab-case CSS property name; `value` is a fully
+ * formatted CSS value string. Shorthand-policy guards do not apply
+ * to RawOps (they are intentionally outside the safety net — that's
+ * what "unsafe" means).
+ */
+export interface RawOp {
+    readonly property: string;
+    readonly value: string;
+}
+/**
+ * Discriminated union of chain ops. Use `isMethodOp` / `isScopedOp` /
+ * `isRawOp` to narrow at consumption sites.
+ */
+export type Op = MethodOp | ScopedOp | RawOp;
+export declare function isMethodOp(op: Op): op is MethodOp;
+export declare function isScopedOp(op: Op): op is ScopedOp;
+export declare function isRawOp(op: Op): op is RawOp;
+/**
+ * One scoping layer in a chain. The Canonicalizer turns these into
+ * nested rule selectors (`& :hover { ... }`, `@media (...) { ... }`).
+ *
+ * - `pseudo`: ":hover", ":focus", "::before", etc. — always prefixed by `&`.
+ * - `media`:  the parenthesized query body, sans `@media`.
+ * - `raw`:    arbitrary CSS selector text appended after `&` (e.g.
+ *             `[data-loading="true"]`, `> *`). Use sparingly.
+ */
+export type Scope = {
+    readonly kind: 'pseudo';
+    readonly selector: string;
+} | {
+    readonly kind: 'media';
+    readonly query: string;
+} | {
+    readonly kind: 'raw';
+    readonly selector: string;
+};
+/**
+ * Canonical, post-LIFO property map. Keys are CSS property names
+ * (`margin-top`, not `marginTop`); values are CSS-ready strings or
+ * the dynamic placeholder.
+ */
+export type PropertyBag = Readonly<Record<string, string>>;
+/**
+ * Recursive scope-tree produced by `Canonicalizer.collapse`.
+ *
+ * Each node owns the declarations *directly* applied at its scope
+ * (e.g. the base node owns un-modified declarations; a `:hover` child
+ * owns declarations written inside `.hover(c => ...)`).
+ *
+ * The hash is computed over the entire tree, so two structurally
+ * identical chains share a class regardless of textual differences in
+ * the source.
+ */
+export interface ScopeBag {
+    /** `null` for the root (base scope); `Scope` for any nested layer. */
+    readonly scope: Scope | null;
+    readonly bag: PropertyBag;
+    readonly slots: Readonly<Record<string, string>>;
+    readonly children: readonly ScopeBag[];
+}
+/**
+ * One dynamic slot in a compiled rule. The CSS rule emits
+ * `<property>: var(<varName>)`; the parser injects the source AST node
+ * as the value of `<varName>` in the element's inline style.
+ *
+ * `scopePath` describes where in the scope tree this slot lives; it is
+ * informational only (the var name already encodes uniqueness via the
+ * className hash).
+ */
+export interface DynamicSlot {
+    readonly property: string;
+    readonly varName: string;
+    readonly sourceId: string;
+    readonly animatable: boolean;
+    readonly syntax: string | undefined;
+    readonly initialValue: string | undefined;
+    readonly scopePath: readonly Scope[];
+}
+/**
+ * Result of compiling an `Op[]` chain.
+ *
+ * - `canonical` is the deterministic key from which `className` was
+ *   derived (placeholders for dynamics, sorted scope-tree shape).
+ * - `tree` is CSS-emission-ready: dynamic entries already substituted
+ *   with `var(--<className>-<scope>-<prop>)`. The emitter walks the
+ *   tree, builds nested CSS, and runs it through stylis.
+ * - `dynamics` lists every dynamic slot in source order; the parser
+ *   maps each `sourceId` back to its AST expression to populate the
+ *   inline style attribute.
+ */
+export interface CompiledRule {
+    readonly className: string;
+    readonly tree: ScopeBag;
+    readonly canonical: string;
+    readonly dynamics: readonly DynamicSlot[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,28 @@
+/**
+ * Marker for arguments the parser could not statically evaluate. The
+ * parser stashes the original AST node behind `id`; the compiler treats
+ * these as opaque placeholders for canonical-key purposes and wires the
+ * surviving slot into the resulting `CompiledRule.dynamics` list.
+ */
+export const DYNAMIC_TAG = '__fss_dynamic__';
+export function isDynamic(v) {
+    return (typeof v === 'object' &&
+        v !== null &&
+        v[DYNAMIC_TAG] === true);
+}
+/**
+ * Sentinel value placed in a property bag for slots whose value is
+ * dynamic. The choice of ` ` makes accidental collision with a
+ * real CSS string impossible.
+ */
+export const DYNAMIC_PLACEHOLDER = ' <FSS_DYN> ';
+export function isMethodOp(op) {
+    return 'method' in op;
+}
+export function isScopedOp(op) {
+    return 'scope' in op && 'ops' in op;
+}
+export function isRawOp(op) {
+    return 'property' in op && 'value' in op;
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,CAAC;AAO7C,MAAM,UAAU,SAAS,CAAC,CAAU;IAClC,OAAO,CACL,OAAO,CAAC,KAAK,QAAQ;QACrB,CAAC,KAAK,IAAI;QACT,CAAiC,CAAC,WAAW,CAAC,KAAK,IAAI,CACzD,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,aAAa,CAAC;AAwCjD,MAAM,UAAU,UAAU,CAAC,EAAM;IAC/B,OAAO,QAAQ,IAAI,EAAE,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,EAAM;IAC/B,OAAO,OAAO,IAAI,EAAE,IAAI,KAAK,IAAI,EAAE,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,EAAM;IAC5B,OAAO,UAAU,IAAI,EAAE,IAAI,OAAO,IAAI,EAAE,CAAC;AAC3C,CAAC"}

package/dist/util.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert kebab-case CSS property names to camelCase keys (the form used
+ * by React's `style` prop and `csstype.Properties`).
+ */
+export declare const cssToCamel: (prop: string) => string;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,MACiC,CAAC"}

package/dist/util.js

@@ -0,0 +1,6 @@
+/**
+ * Convert kebab-case CSS property names to camelCase keys (the form used
+ * by React's `style` prop and `csstype.Properties`).
+ */
+export const cssToCamel = (prop) => prop.replace(/-([a-z])/g, (_match, c) => c.toUpperCase());
+//# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,IAAY,EAAU,EAAE,CACjD,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,MAAc,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@cassida/compiler",
+  "version": "0.1.0",
+  "description": "Cassida build-time CSS resolver: registry, canonicalizer, hasher, emitter.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "config.schema.json"
+  ],
+  "dependencies": {
+    "csstype": "^3.1.3",
+    "stylis": "^4.3.4",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.9.0",
+    "@types/stylis": "^4.2.7",
+    "mdn-data": "^2.13.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pishio/cassida.git",
+    "directory": "packages/compiler"
+  },
+  "homepage": "https://github.com/pishio/cassida/tree/main/packages/compiler#readme",
+  "bugs": {
+    "url": "https://github.com/pishio/cassida/issues"
+  },
+  "author": "pishio",
+  "keywords": [
+    "cassida",
+    "css-in-js",
+    "compile-time",
+    "single-class",
+    "react"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "codegen": "tsx scripts/generate-property-specs.ts"
+  }
+}