@teacss/engine 0.8.5-alpha.4 → 0.9.0-alpha.4

package/src/facade/transformer.mjs

@@ -1,56 +0,0 @@
-// @ts-check
-import { ENGINE_INSTANCE } from "./constants.mjs";
-
-/**
- * Replays v02.2 `TransformResult.edits` on the host MagicString. A zero-length range is an insert:
- * magic-string throws on a zero-length `update`.
- * @param {{ update(start: number, end: number, text: string): unknown, appendLeft(index: number, text: string): unknown }} s
- * @param {{ start: number, end: number, text: string }[]} edits
- */
-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);
-  }
-}
-
-/** @param {any} ctx */
-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",
-    /** @param {any} s @param {string} id @param {any} ctx */
-    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).
-     * @param {string} id @param {any} ctx
-     */
-    onModuleRemoved(id, ctx) {
-      const engine = engineOf(ctx);
-      if (!engine) return;
-      let changed = false;
-      try {
-        changed = engine.clearModuleDefinitions(id);
-      } catch (error) {
-        if (/** @type {any} */ (error)?.code !== "E_DISPOSED") throw error;
-      }
-      if (changed) ctx.invalidate?.();
-    },
-  };
-}

package/src/facade/ts-fallback.mjs

@@ -1,88 +0,0 @@
-// @ts-check
-// The lazily created TypeScript generator behind the facade (v02.9 §3.3).
-
-import { ENGINE_INSTANCE } from "./constants.mjs";
-import { tsRequiredError } from "./errors.mjs";
-
-/** @typedef {{ version: string, createGenerator: (config?: object, defaults?: object) => Promise<any>, extractorSplit: object }} CoreBinding */
-
-/** Test seam that replaces the dynamic import of `@teacss/core`. */
-export const coreLoader = {
-  /** @type {(() => Promise<CoreBinding>) | null} */
-  load: null,
-};
-
-/** @param {string} member @returns {Promise<CoreBinding>} rejects with `E_TS_REQUIRED` when the peer is missing */
-export async function importCore(member) {
-  try {
-    // @ts-ignore optional peer
-    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.
- * @param {{ core?: CoreBinding | undefined }} host
- * @param {{ userConfig: object, defaults: object }} committed the configuration committed at construction
- */
-export function createTsFallback(host, committed) {
-  /** @type {Promise<any> | null} */
-  let generatorPromise = null;
-  /** @type {any} */
-  let resolved = null;
-  /** @param {string} member */
-  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.
-   * @param {any} binding @param {object} userConfig @param {object} defaults
-   */
-  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. @param {object} userConfig @param {object} defaults */
-    invalidate(userConfig, defaults) {
-      committed = { userConfig, defaults };
-      generatorPromise = null;
-      resolved = null;
-    },
-    /** The lazy TS generator; a rejection is not cached. @param {string} [member] */
-    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.
-     * @param {object} userConfig @param {object} defaults
-     */
-    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 base;
-      return (await base.prepareConfig(userConfig, tsDefaults)).generator;
-    },
-  };
-}