@ttsc/unplugin 0.8.0

package/src/bun.ts

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+import type { UnpluginContextMeta } from "unplugin";
+
+import { unplugin } from "./api";
+import type { TtscUnpluginOptions } from "./core/options";
+
+export interface BunLikePlugin {
+  name: string;
+  setup(build: BunLikeBuild): void | Promise<void>;
+}
+
+export interface BunLikeBuild {
+  onLoad(
+    options: { filter: RegExp },
+    loader: (args: { path: string }) => Promise<{ contents: string }>,
+  ): void;
+}
+
+const sourceFilePattern = /\.[cm]?[jt]sx?$/;
+
+export default function bun(options?: TtscUnpluginOptions): BunLikePlugin {
+  return {
+    name: "ttsc-unplugin",
+    setup(build) {
+      const raw = unplugin.raw(options, {} as UnpluginContextMeta);
+      build.onLoad({ filter: sourceFilePattern }, async (args) => {
+        const source = await fs.readFile(args.path, "utf8");
+        const result =
+          typeof raw.transform === "function"
+            ? await raw.transform.call({} as never, source, args.path)
+            : undefined;
+        if (typeof result === "string") {
+          return { contents: result };
+        }
+        if (
+          typeof result === "object" &&
+          result !== null &&
+          "code" in result &&
+          typeof result.code === "string"
+        ) {
+          return { contents: result.code };
+        }
+        return { contents: source };
+      });
+    },
+  };
+}

package/src/core/index.ts

@@ -0,0 +1,61 @@
+import type { UnpluginFactory, UnpluginInstance } from "unplugin";
+import { createUnplugin } from "unplugin";
+
+import type { TtscUnpluginOptions } from "./options";
+import { resolveOptions } from "./options";
+import { isDeclarationFile, stripQuery, transformTtsc } from "./transform";
+
+const name = "ttsc-unplugin";
+const sourceFilePattern = /\.[cm]?[jt]sx?$/;
+const nodeModulesPattern = /(?:^|[/\\])node_modules(?:[/\\]|$)/;
+
+const unpluginFactory: UnpluginFactory<
+  TtscUnpluginOptions | undefined,
+  false
+> = (rawOptions = {}) => {
+  const options = resolveOptions(rawOptions);
+  let aliases: unknown;
+
+  return {
+    name,
+    enforce: "pre",
+
+    vite: {
+      configResolved(config) {
+        aliases = config.resolve.alias;
+      },
+    },
+
+    transformInclude(id) {
+      const file = stripQuery(id);
+      return isTransformTarget(file);
+    },
+
+    async transform(source, id) {
+      const file = stripQuery(id);
+      if (!isTransformTarget(file)) {
+        return undefined;
+      }
+      return transformTtsc(file, source, options, aliases);
+    },
+  };
+};
+
+const unplugin: UnpluginInstance<TtscUnpluginOptions | undefined, false> =
+  createUnplugin(unpluginFactory);
+
+export type {
+  TtscUnpluginCompilerOptionsJson,
+  TtscUnpluginOptions,
+} from "./options";
+export { resolveOptions, transformTtsc, unplugin };
+
+export default unplugin;
+
+function isTransformTarget(id: string): boolean {
+  return (
+    sourceFilePattern.test(id) &&
+    !isDeclarationFile(id) &&
+    !nodeModulesPattern.test(id)
+  );
+}

package/src/core/options.ts

@@ -0,0 +1,52 @@
+import type { ITtscProjectPluginConfig } from "ttsc";
+
+export type TtscUnpluginCompilerOptionsJson = Record<string, unknown>;
+
+export interface TtscUnpluginOptions {
+  /**
+   * Project config used by the bundler adapter.
+   *
+   * Relative paths resolve from `process.cwd()`. When omitted, the nearest
+   * `tsconfig.json` is discovered from the transformed file.
+   */
+  project?: string;
+
+  /**
+   * Compiler options overlaid on top of the selected project config.
+   *
+   * This can include `plugins`; `plugins` passed at the top level still wins as
+   * the explicit plugin override.
+   */
+  compilerOptions?: TtscUnpluginCompilerOptionsJson;
+
+  /**
+   * `ttsc` plugin entries.
+   *
+   * `undefined` reads `compilerOptions.plugins` from the project config,
+   * `false` disables project plugins, and an array overrides the project
+   * plugin list.
+   */
+  plugins?: readonly ITtscProjectPluginConfig[] | false;
+}
+
+export interface ResolvedTtscUnpluginOptions {
+  compilerOptions: TtscUnpluginCompilerOptionsJson;
+  plugins?: readonly ITtscProjectPluginConfig[] | false;
+  project?: string;
+}
+
+const defaultOptions: ResolvedTtscUnpluginOptions = {
+  compilerOptions: {},
+  plugins: undefined,
+  project: undefined,
+};
+
+export function resolveOptions(
+  options: TtscUnpluginOptions = {},
+): ResolvedTtscUnpluginOptions {
+  return {
+    compilerOptions: { ...(options.compilerOptions ?? {}) },
+    plugins: "plugins" in options ? options.plugins : defaultOptions.plugins,
+    project: options.project ?? defaultOptions.project,
+  };
+}

package/src/core/transform.ts

@@ -0,0 +1,357 @@
+import * as Diff from "diff-match-patch-es";
+import fs from "node:fs";
+import path from "node:path";
+import MagicString from "magic-string";
+import type {
+  ITtscCompilerDiagnostic,
+  ITtscCompilerTransformation,
+} from "ttsc";
+import { TtscCompiler } from "ttsc";
+import type { TransformResult } from "unplugin";
+
+import type { ResolvedTtscUnpluginOptions } from "./options";
+
+export type TtscTransformResult = Exclude<
+  TransformResult,
+  string | null | undefined
+>;
+
+export interface TtscTransformAlias {
+  find: string | RegExp;
+  replacement: string;
+}
+
+export async function transformTtsc(
+  id: string,
+  source: string,
+  options: ResolvedTtscUnpluginOptions,
+  aliases?: unknown,
+): Promise<TtscTransformResult | undefined> {
+  const file = path.resolve(stripQuery(id));
+  if (isDeclarationFile(file)) {
+    return undefined;
+  }
+
+  const tsconfig = resolveTsconfig(file, options.project);
+  const tsconfigDir = path.dirname(tsconfig);
+  const baseUrl = resolveBaseUrl(tsconfigDir, options.compilerOptions);
+  const aliasPaths = createAliasPaths(baseUrl, aliases);
+  const configured = createTransformTsconfig({
+    aliasPaths,
+    baseUrl,
+    compilerOptions: options.compilerOptions,
+    tsconfig,
+  });
+  try {
+    const effectiveTsconfig = configured.path;
+    const result = new TtscCompiler({
+      cwd: path.dirname(effectiveTsconfig),
+      plugins: options.plugins,
+      tsconfig: effectiveTsconfig,
+    }).transform();
+    const code = selectTransformedSource({
+      file,
+      projectRoot: path.dirname(effectiveTsconfig),
+      result,
+    });
+    return createTransformResult(source, code, file);
+  } finally {
+    configured.dispose();
+  }
+}
+
+export function stripQuery(id: string): string {
+  const query = id.search(/[?#]/);
+  const clean = query === -1 ? id : id.slice(0, query);
+  return clean.endsWith("?__rslib_entry__")
+    ? clean.slice(0, -"?__rslib_entry__".length)
+    : clean;
+}
+
+export function isDeclarationFile(id: string): boolean {
+  return id.endsWith(".d.ts") || id.endsWith(".d.mts") || id.endsWith(".d.cts");
+}
+
+export function createTransformResult(
+  source: string,
+  code: string,
+  id: string,
+): TtscTransformResult | undefined {
+  if (source === code) {
+    return undefined;
+  }
+
+  const magic = new MagicString(source);
+  const diff = Diff.diff(source, code);
+  Diff.diffCleanupSemantic(diff);
+
+  let offset = 0;
+  for (let index = 0; index < diff.length; index += 1) {
+    const [type, text] = diff[index]!;
+    if (type === 0) {
+      offset += text.length;
+      continue;
+    }
+    if (type === 1) {
+      magic.prependLeft(offset, text);
+      continue;
+    }
+
+    const next = diff[index + 1];
+    if (next?.[0] === 1) {
+      magic.update(offset, offset + text.length, next[1]);
+      index += 1;
+    } else {
+      magic.remove(offset, offset + text.length);
+    }
+    offset += text.length;
+  }
+
+  if (!magic.hasChanged()) {
+    return undefined;
+  }
+  return {
+    code: magic.toString(),
+    map: magic.generateMap({
+      file: `${id}.map`,
+      includeContent: true,
+      source: id,
+    }),
+  };
+}
+
+function createTransformTsconfig(props: {
+  aliasPaths: Record<string, string[]>;
+  baseUrl: string;
+  compilerOptions: Record<string, unknown>;
+  tsconfig: string;
+}): { path: string; dispose: () => void } {
+  const compilerOptions = {
+    ...props.compilerOptions,
+    ...createAliasCompilerOptions(props),
+  };
+  if (Object.keys(compilerOptions).length === 0) {
+    return {
+      path: props.tsconfig,
+      dispose: () => undefined,
+    };
+  }
+
+  const directory = path.dirname(props.tsconfig);
+  const file = path.join(
+    directory,
+    `.ttsc-unplugin-${process.pid}-${Date.now()}-${Math.random()
+      .toString(36)
+      .slice(2)}.json`,
+  );
+  fs.writeFileSync(
+    file,
+    JSON.stringify(
+      {
+        extends: `./${path.basename(props.tsconfig)}`,
+        compilerOptions,
+      },
+      null,
+      2,
+    ),
+    "utf8",
+  );
+  return {
+    path: file,
+    dispose: () => fs.rmSync(file, { force: true }),
+  };
+}
+
+function createAliasCompilerOptions(props: {
+  aliasPaths: Record<string, string[]>;
+  baseUrl: string;
+  compilerOptions: Record<string, unknown>;
+}): Record<string, unknown> {
+  if (Object.keys(props.aliasPaths).length === 0) {
+    return {};
+  }
+  return {
+    baseUrl: toCompilerPath(props.baseUrl, props.compilerOptions),
+    paths: {
+      ...readPaths(props.compilerOptions.paths),
+      ...props.aliasPaths,
+    },
+  };
+}
+
+function readPaths(value: unknown): Record<string, string[]> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {};
+  }
+  const output: Record<string, string[]> = {};
+  for (const [key, paths] of Object.entries(value)) {
+    if (!Array.isArray(paths)) {
+      continue;
+    }
+    const filtered = paths.filter(
+      (entry): entry is string => typeof entry === "string",
+    );
+    if (filtered.length !== 0) {
+      output[key] = filtered;
+    }
+  }
+  return output;
+}
+
+function resolveBaseUrl(
+  tsconfigDir: string,
+  compilerOptions: Record<string, unknown>,
+): string {
+  return typeof compilerOptions.baseUrl === "string"
+    ? path.resolve(tsconfigDir, compilerOptions.baseUrl)
+    : tsconfigDir;
+}
+
+function toCompilerPath(
+  absoluteBaseUrl: string,
+  compilerOptions: Record<string, unknown>,
+): string {
+  return typeof compilerOptions.baseUrl === "string"
+    ? compilerOptions.baseUrl
+    : absoluteBaseUrl;
+}
+
+function createAliasPaths(
+  baseUrl: string,
+  aliases: unknown,
+): Record<string, string[]> {
+  const paths: Record<string, string[]> = {};
+  for (const alias of normalizeAliases(aliases)) {
+    if (typeof alias.find !== "string" || alias.find.length === 0) {
+      continue;
+    }
+    if (alias.find.includes("*")) {
+      continue;
+    }
+    const key = alias.find.replace(/\/+$/, "");
+    if (key.length === 0) {
+      continue;
+    }
+    const replacement = path.isAbsolute(alias.replacement)
+      ? alias.replacement
+      : path.resolve(process.cwd(), alias.replacement);
+    const target = normalizePath(path.relative(baseUrl, replacement) || ".");
+    paths[key] = [target];
+    paths[`${key}/*`] = [`${target}/*`];
+  }
+  return paths;
+}
+
+function normalizeAliases(aliases: unknown): TtscTransformAlias[] {
+  if (Array.isArray(aliases)) {
+    return aliases.filter(isAlias);
+  }
+  if (typeof aliases === "object" && aliases !== null) {
+    return Object.entries(aliases)
+      .filter(
+        (entry): entry is [string, string] => typeof entry[1] === "string",
+      )
+      .map(([find, replacement]) => ({ find, replacement }));
+  }
+  return [];
+}
+
+function isAlias(value: unknown): value is TtscTransformAlias {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "find" in value &&
+    "replacement" in value &&
+    (typeof value.find === "string" || value.find instanceof RegExp) &&
+    typeof value.replacement === "string"
+  );
+}
+
+function selectTransformedSource(props: {
+  file: string;
+  projectRoot: string;
+  result: ITtscCompilerTransformation;
+}): string {
+  if (props.result.type === "exception") {
+    throw new Error(formatUnknownError(props.result.error));
+  }
+  if (props.result.type === "failure") {
+    throw new Error(formatDiagnostics(props.result.diagnostics));
+  }
+
+  const key = toProjectKey(props.projectRoot, props.file);
+  const direct = props.result.typescript[key];
+  if (direct !== undefined) {
+    return direct;
+  }
+  for (const [candidate, source] of Object.entries(props.result.typescript)) {
+    if (path.resolve(props.projectRoot, candidate) === props.file) {
+      return source;
+    }
+  }
+  throw new Error(`ttsc transform did not return output for ${props.file}`);
+}
+
+function formatDiagnostics(diagnostics: ITtscCompilerDiagnostic[]): string {
+  if (diagnostics.length === 0) {
+    return "ttsc transform failed";
+  }
+  return diagnostics
+    .map((diag) =>
+      [
+        diag.file ?? "ttsc",
+        diag.line === undefined
+          ? undefined
+          : `${diag.line}:${diag.character ?? 1}`,
+        diag.messageText,
+      ]
+        .filter((part) => part !== undefined && part !== "")
+        .join(": "),
+    )
+    .join("\n");
+}
+
+function formatUnknownError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "message" in error &&
+    typeof error.message === "string"
+  ) {
+    return error.message;
+  }
+  return String(error);
+}
+
+function resolveTsconfig(file: string, tsconfig?: string): string {
+  if (tsconfig !== undefined) {
+    return path.isAbsolute(tsconfig)
+      ? tsconfig
+      : path.resolve(process.cwd(), tsconfig);
+  }
+
+  let current = path.dirname(file);
+  while (true) {
+    const candidate = path.join(current, "tsconfig.json");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return path.resolve(process.cwd(), "tsconfig.json");
+}
+
+function toProjectKey(root: string, file: string): string {
+  return normalizePath(path.relative(root, file));
+}
+
+function normalizePath(file: string): string {
+  return file.replace(/\\/g, "/");
+}

package/src/esbuild.ts

@@ -0,0 +1,5 @@
+import unplugin from "./core/index";
+
+const esbuild: typeof unplugin.esbuild = unplugin.esbuild;
+
+export default esbuild;

package/src/farm.ts

@@ -0,0 +1,5 @@
+import unplugin from "./core/index";
+
+const farm: typeof unplugin.farm = unplugin.farm;
+
+export default farm;

package/src/index.ts

@@ -0,0 +1,5 @@
+import unplugin from "./core/index";
+
+export type { TtscUnpluginOptions } from "./core/options";
+
+export default unplugin;

package/src/next.ts

@@ -0,0 +1,27 @@
+import type { TtscUnpluginOptions } from "./core/options";
+import webpack from "./webpack";
+
+export type NextLikeConfig = Record<string, unknown> & {
+  webpack?: (config: WebpackLikeConfig, options: unknown) => WebpackLikeConfig;
+};
+
+export type WebpackLikeConfig = Record<string, unknown> & {
+  plugins?: unknown[];
+};
+
+export default function next(
+  nextConfig: NextLikeConfig = {},
+  options?: TtscUnpluginOptions,
+): NextLikeConfig {
+  return {
+    ...nextConfig,
+    webpack(config: WebpackLikeConfig, webpackOptions: unknown) {
+      config.plugins = Array.isArray(config.plugins) ? config.plugins : [];
+      config.plugins.unshift(webpack(options));
+      if (typeof nextConfig.webpack === "function") {
+        return nextConfig.webpack(config, webpackOptions);
+      }
+      return config;
+    },
+  };
+}

package/src/rolldown.ts

@@ -0,0 +1,5 @@
+import unplugin from "./core/index";
+
+const rolldown: typeof unplugin.rolldown = unplugin.rolldown;
+
+export default rolldown;

package/src/rollup.ts

@@ -0,0 +1,5 @@
+import unplugin from "./core/index";
+
+const rollup: typeof unplugin.rollup = unplugin.rollup;
+
+export default rollup;

package/src/rspack.ts

@@ -0,0 +1,5 @@
+import unplugin from "./core/index";
+
+const rspack: typeof unplugin.rspack = unplugin.rspack;
+
+export default rspack;

package/src/vite.ts

@@ -0,0 +1,5 @@
+import unplugin from "./core/index";
+
+const vite: typeof unplugin.vite = unplugin.vite;
+
+export default vite;

package/src/webpack.ts

@@ -0,0 +1,5 @@
+import unplugin from "./core/index";
+
+const webpack: typeof unplugin.webpack = unplugin.webpack;
+
+export default webpack;