@lass-lang/core 0.0.1

package/dist/transpiler.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Transpiler pipeline functions for @lass-lang/core
+ *
+ * Each function represents a step in the transpilation story.
+ * See index.ts for the main entry point that orchestrates these steps.
+ */
+import type { DetectedZones, ProcessedTemplate, DollarResolutionResult, TranspileOptions } from './types.js';
+/**
+ * Step 1: Detect and split zones.
+ *
+ * Finds the --- separator and splits source into preamble and CSS zones.
+ * If no separator, entire source is the CSS zone (pure CSS passthrough).
+ *
+ * @param source - Raw Lass source code
+ * @param options - Transpile options (filename for errors)
+ * @returns Detected zones with preamble and cssZone
+ */
+export declare function detectZones(source: string, options: TranspileOptions): DetectedZones;
+/**
+ * Step 2: Strip // comments from CSS zone.
+ *
+ * Story 4.4: Single-line comment stripping.
+ * Removes // comments while respecting protected contexts (strings, url(), block comments).
+ *
+ * @param cssZone - The CSS zone content
+ * @returns CSS zone with // comments removed
+ */
+export declare function stripLineComments(cssZone: string): string;
+/**
+ * Step 3a: Normalize @prop shorthands to @(prop) form.
+ *
+ * Story 4.2: Style Lookup Shorthand
+ *
+ * Finds @prop patterns in CSS value position and converts them to @(prop).
+ * This runs BEFORE @(prop) resolution so all lookups are handled uniformly.
+ *
+ * Detection rules:
+ * - @prop shorthand only works when identifier starts with a letter [a-zA-Z]
+ * - NOT detected inside {{ }} script blocks
+ * - NOT detected inside protected contexts: strings, comments, url()
+ *
+ * @param cssZone - The CSS zone content
+ * @returns CSS zone with @prop normalized to @(prop)
+ */
+export declare function normalizeStyleLookupShorthands(cssZone: string): string;
+/**
+ * Step 3b: Resolve @(prop) accessors in CSS zone.
+ *
+ * Story 3.2: Basic Property Lookup
+ * Story 3.3: Lookup in {{ }} Context
+ * Refactored: Changed from @prop to @(prop) for unambiguous syntax
+ *
+ * Finds @(prop) patterns in CSS value position and resolves them to their
+ * previously-declared values using scope tracking utilities.
+ *
+ * Resolution rules:
+ * - Property found in CSS context -> Replace @(prop) with resolved value
+ * - Property found in JS context (inside {{ }}) -> Replace with quoted value
+ * - Property not found -> Preserve @(prop) unchanged (PostCSS/future CSS compatibility)
+ *
+ * This is Phase 1 of transpilation and runs BEFORE {{ }} processing.
+ *
+ * @param cssZone - The CSS zone content
+ * @param options - Transpile options (filename for errors)
+ * @returns CSS zone with @(prop) accessors resolved (or preserved if not found)
+ */
+export declare function resolvePropertyAccessors(cssZone: string, _options: TranspileOptions): string;
+/**
+ * Step 4: Replace $param variables with __lassScriptLookup() calls.
+ *
+ * Story 4.1: Variable Substitution
+ *
+ * Finds $param patterns in CSS zone and converts them to helper function calls.
+ * This enables $-prefixed variables from the preamble to be substituted into CSS
+ * with proper handling of null (-> 'unset') and undefined/missing (-> preserved).
+ *
+ * Protected contexts (strings, url(), comments) are skipped - $param inside these
+ * remains as literal text. Use {{ $param }} for dynamic content in protected contexts.
+ *
+ * @param cssZone - The CSS zone content
+ * @param _options - Transpile options (filename for errors)
+ * @returns Result with modified CSS zone and flag indicating if helpers needed
+ */
+export declare function resolveDollarVariables(cssZone: string, _options: TranspileOptions): DollarResolutionResult;
+/**
+ * Normalizes style block content by trimming and dedenting.
+ *
+ * Single-line (no newlines): Trim leading/trailing whitespace.
+ * Multi-line:
+ *   - Dedent all lines by the minimum indentation found
+ *   - Trim leading and trailing whitespace
+ *
+ * @param content - Raw content from inside @{ }
+ * @returns Normalized content
+ */
+export declare function normalizeStyleBlockContent(content: string): string;
+/**
+ * Result from style block translation.
+ */
+export interface StyleBlockTranslationResult {
+    /** The translated text */
+    text: string;
+    /** Whether any $param variables were found in style blocks */
+    hasDollarVariables: boolean;
+}
+/**
+ * Translates @{ } style blocks to JS template literals.
+ *
+ * Story 5.1: Style Block Syntax
+ *
+ * @{ } is purely delimiter translation:
+ * - @{ → backtick (`)
+ * - } (matching @{) → backtick (`)
+ * - {{ }} inside @{ } → ${ } with __lassScriptExpression helper
+ * - $param inside @{ } → ${__lassScriptLookup(...)} for proper null/undefined handling
+ *
+ * This function handles brace matching to find the correct closing }.
+ * Nested braces (from object literals, ternaries, etc.) are tracked.
+ *
+ * Protected contexts (where @{ is NOT translated):
+ * - Inside string literals ("..." or '...')
+ * - Inside block comments
+ * - Note: url() is NOT protected - @{ inside url() IS translated
+ *
+ * @param text - JS code containing @{ } style blocks
+ * @returns Result with translated text and flag for $param usage
+ */
+export declare function translateStyleBlocks(text: string): StyleBlockTranslationResult;
+/**
+ * Step 5b: Process expressions in CSS zone.
+ *
+ * Finds {{ expr }} expressions and converts them to template literal interpolations.
+ * Story 2.5: Expressions are processed EVERYWHERE in CSS zone (strings, url(), comments).
+ * Story 5.1: Also translates @{ } style blocks within expressions.
+ *
+ * @param cssZone - The CSS zone content
+ * @param hasDollarVariables - Whether $param variables were found in CSS zone
+ * @param options - Transpile options (filename for errors)
+ * @returns Processed template with body and expression flag
+ */
+export declare function processExpressions(cssZone: string, hasDollarVariables: boolean, options: TranspileOptions): ProcessedTemplate;
+/**
+ * Step 6: Build final JavaScript module output.
+ *
+ * Assembles preamble, helper functions (if needed), and template literal export.
+ * Story 5.1: Also translates @{ } style blocks in preamble.
+ *
+ * @param zones - Detected zones from step 1
+ * @param template - Processed template from step 5
+ * @returns Final JavaScript module code
+ */
+export declare function buildOutput(zones: DetectedZones, template: ProcessedTemplate): string;
+//# sourceMappingURL=transpiler.d.ts.map

package/dist/transpiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpiler.d.ts","sourceRoot":"","sources":["../src/transpiler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAM7G;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,aAAa,CASpF;AAMD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzD;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAuBtE;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAsF5F;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,sBAAsB,CA2B1G;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA8BlE;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,2BAA2B,CAgF9E;AAoOD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,GAAG,iBAAiB,CA6C7H;AAMD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAgCrF"}