@teacss/engine 0.9.4 → 0.10.2

package/dist/transformer.d.ts

@@ -1,44 +0,0 @@
-import type { HighlightAnnotation, TransformResult } from "../contract.js";
-import { ENGINE_INSTANCE } from "./constants.js";
-interface EditTarget {
-    update(start: number, end: number, text: string): unknown;
-    appendLeft(index: number, text: string): unknown;
-}
-/** The part of the native `Engine` the transformer calls. */
-interface TransformEngine {
-    transformSource(id: string, code: string): TransformResult | null;
-    clearModuleDefinitions(id: string): boolean;
-}
-/** The runtime's transformer context; only the fields the transformer reads. */
-interface TransformContext {
-    generator?: {
-        [ENGINE_INSTANCE]?: TransformEngine;
-    };
-    tokens?: Set<string>;
-    invalidate?: () => void;
-}
-/**
- * Replays v02.2 `TransformResult.edits` on the host MagicString. A zero-length range is an insert:
- * magic-string throws on a zero-length `update`.
- */
-export declare function replayEdits(s: EditTarget, edits: ReadonlyArray<{
-    start: number;
-    end: number;
-    text: string;
-}>): void;
-/**
- * The object shape of preset-standard/transformers/compile-class.ts:178-274, backed by Rust
- * `transformSource`. It has no `idFilter`: the runtime's pipeline filter picks the modules.
- */
-export declare function createCompileClassTransformer(): {
-    name: "@teacss/transformer-compile-class";
-    enforce: "pre";
-    transform(s: EditTarget & {
-        original: string;
-    }, id: string, ctx: TransformContext): Promise<{
-        highlightAnnotations: HighlightAnnotation[];
-    } | undefined>;
-    onModuleRemoved(id: string, ctx: TransformContext): void;
-};
-export {};
-//# sourceMappingURL=transformer.d.ts.map

package/dist/transformer.js

@@ -1,59 +0,0 @@
-import { ENGINE_INSTANCE } from "./constants.js";
-/**
- * Replays v02.2 `TransformResult.edits` on the host MagicString. A zero-length range is an insert:
- * magic-string throws on a zero-length `update`.
- */
-export function replayEdits(s, edits) {
-    for (const { start, end, text } of edits) {
-        if (start === end)
-            s.appendLeft(start, text);
-        else
-            s.update(start, end, text);
-    }
-}
-const engineOf = (ctx) => ctx?.generator?.[ENGINE_INSTANCE] ?? null;
-/**
- * The object shape of preset-standard/transformers/compile-class.ts:178-274, backed by Rust
- * `transformSource`. It has no `idFilter`: the runtime's pipeline filter picks the modules.
- */
-export function createCompileClassTransformer() {
-    return {
-        name: "@teacss/transformer-compile-class",
-        enforce: "pre",
-        async transform(s, id, ctx) {
-            const engine = engineOf(ctx);
-            if (!engine)
-                return;
-            const result = engine.transformSource(id, s.original);
-            if (!result)
-                return;
-            replayEdits(s, result.edits);
-            if (ctx.tokens)
-                for (const name of result.compiledClasses)
-                    ctx.tokens.add(name);
-            if (result.definitionsChanged)
-                ctx.invalidate?.();
-            return { highlightAnnotations: result.highlightAnnotations };
-        },
-        /**
-         * Releases the module's definitions only: the runtime also calls this when a module stays
-         * (context switches, failed transforms), so its tokens are kept (v02.9 §6.1 step 8).
-         */
-        onModuleRemoved(id, ctx) {
-            const engine = engineOf(ctx);
-            if (!engine)
-                return;
-            let changed = false;
-            try {
-                changed = engine.clearModuleDefinitions(id);
-            }
-            catch (error) {
-                if (error?.code !== "E_DISPOSED")
-                    throw error;
-            }
-            if (changed)
-                ctx.invalidate?.();
-        },
-    };
-}
-//# sourceMappingURL=transformer.js.map

package/dist/ts-fallback.d.ts

@@ -1,41 +0,0 @@
-/** A TypeScript generator from `@teacss/core`; the facade only forwards to it. */
-export type TsGenerator = any;
-export interface CoreBinding {
-    version: string;
-    createGenerator: (config?: object, defaults?: object) => Promise<TsGenerator>;
-    createTsGenerator?: (config?: object, defaults?: object) => Promise<TsGenerator>;
-    extractorSplit: object;
-}
-/** Test seam that replaces the dynamic import of `@teacss/core`. */
-export declare const coreLoader: {
-    load: (() => Promise<CoreBinding>) | null;
-};
-/** Rejects with `E_TS_REQUIRED` when the peer is missing. */
-export declare function importCore(member: string): Promise<CoreBinding>;
-export interface TsFallback {
-    invalidate(userConfig: object, defaults: object): void;
-    generator(member?: string): Promise<TsGenerator>;
-    peek(): TsGenerator | null;
-    create(userConfig: object, defaults: object): Promise<TsCandidate>;
-}
-/**
- * A prepared TS configuration. `commit` runs the base generator's own `commitConfig`, which
- * re-reads in-place edits of the prepared config (generator.ts:2036-2063), and returns the
- * generator that now serves it, or `null` when the TS generator refused the commit.
- */
-export interface TsCandidate {
-    generator: TsGenerator;
-    commit(): TsGenerator | null;
-}
-/**
- * `engine: "ts"` goes into the defaults, which take precedence over `config.engine`, so the TS
- * generator does not enter the hook again. `committed` is the configuration committed at
- * construction.
- */
-export declare function createTsFallback(host: {
-    core?: CoreBinding | undefined;
-}, committed: {
-    userConfig: object;
-    defaults: object;
-}): TsFallback;
-//# sourceMappingURL=ts-fallback.d.ts.map

package/dist/ts-fallback.js

@@ -1,79 +0,0 @@
-// The lazily created TypeScript generator behind the facade (v02.9 §3.3).
-import { ENGINE_INSTANCE } from "./constants.js";
-import { tsRequiredError } from "./errors.js";
-/** Test seam that replaces the dynamic import of `@teacss/core`. */
-export const coreLoader = {
-    load: null,
-};
-/** Rejects with `E_TS_REQUIRED` when the peer is missing. */
-export async function importCore(member) {
-    try {
-        // biome-ignore lint/suspicious/noTsIgnore: the optional peer may or may not be installed
-        // @ts-ignore optional peer: @teacss/core may be absent at compile time
-        return await (coreLoader.load ? coreLoader.load() : import("@teacss/core"));
-    }
-    catch {
-        throw tsRequiredError(member);
-    }
-}
-/**
- * `engine: "ts"` goes into the defaults, which take precedence over `config.engine`, so the TS
- * generator does not enter the hook again. `committed` is the configuration committed at
- * construction.
- */
-export function createTsFallback(host, committed) {
-    let generatorPromise = null;
-    let resolved = null;
-    const core = (member) => (host.core ? Promise.resolve(host.core) : importCore(member));
-    /**
-     * A TypeScript generator. The hook's `createTsGenerator` bypasses it; `createGenerator` (an older
-     * core, or `@teacss/core` imported without a hook) re-enters it when TEACSS_ENGINE overrides
-     * `engine: "ts"`, and returns a facade for a configuration Rust can serve.
-     */
-    const createTs = (binding, userConfig, defaults) => {
-        const tsDefaults = { ...defaults, engine: "ts" };
-        return typeof binding.createTsGenerator === "function" ? binding.createTsGenerator(userConfig, tsDefaults) : binding.createGenerator(userConfig, tsDefaults);
-    };
-    return {
-        /** Called after a successful `commitConfig`; drops the lazy instance. */
-        invalidate(userConfig, defaults) {
-            committed = { userConfig, defaults };
-            generatorPromise = null;
-            resolved = null;
-        },
-        /** The lazy TS generator; a rejection is not cached. */
-        generator(member = "materialize") {
-            generatorPromise ??= (async () => {
-                const binding = await core(member);
-                const generator = await createTs(binding, committed.userConfig, committed.defaults);
-                resolved = generator;
-                return generator;
-            })().catch((error) => {
-                generatorPromise = null;
-                throw error;
-            });
-            return generatorPromise;
-        },
-        /** The ready instance, or `null` before `generator()` resolves. */
-        peek() {
-            return resolved;
-        },
-        /**
-         * A TS candidate for a configuration (v02.9 §5.2), made by the TS generator's own
-         * `prepareConfig` so it tracks in-place edits of its config as an oracle candidate does
-         * (generator.ts:1986-2011). The lazy instance is untouched.
-         */
-        async create(userConfig, defaults) {
-            const binding = await core("prepareConfig");
-            const tsDefaults = { ...defaults, engine: "ts" };
-            // Without `createTsGenerator` the base is built from the configuration itself: Rust cannot
-            // translate it, so `createGenerator` resolves to TS and creates no Engine.
-            const base = await createTs(binding, typeof binding.createTsGenerator === "function" ? {} : userConfig, defaults);
-            if (ENGINE_INSTANCE in Object(base) || typeof base?.prepareConfig !== "function")
-                return { generator: base, commit: () => base };
-            const prepared = await base.prepareConfig(userConfig, tsDefaults);
-            return { generator: prepared.generator, commit: () => (base.commitConfig(prepared) ? base : null) };
-        },
-    };
-}
-//# sourceMappingURL=ts-fallback.js.map