tw-migrate 0.2.0 → 0.4.0

package/native.js

@@ -1,41 +0,0 @@
-import { createRequire } from "node:module";
-
-const require = createRequire(import.meta.url);
-const targets = {
-  "darwin-arm64": "darwin-arm64",
-  "darwin-x64": "darwin-x64",
-  "linux-arm64": "linux-arm64-gnu",
-  "linux-x64": "linux-x64-gnu",
-  "win32-x64": "win32-x64-msvc",
-};
-const target = targets[`${process.platform}-${process.arch}`];
-
-if (!target) throw new Error(`Unsupported platform: ${process.platform}-${process.arch}`);
-
-let binding;
-for (const load of [
-  () => require(`./tw-migrate.${target}.node`),
-  () => require(`tw-migrate-${target}`),
-]) {
-  try {
-    binding = load();
-    break;
-  } catch (error) {
-    if (error.code !== "MODULE_NOT_FOUND") throw error;
-  }
-}
-
-if (!binding) {
-  throw new Error(
-    `No tw-migrate native addon was found for ${target}. Reinstall the package or build it locally.`,
-  );
-}
-
-export const {
-  decodeSourceMap,
-  planBatchMigration,
-  staticImportBindings,
-  staticImports,
-  staticStringExpression,
-  validateCss,
-} = binding;

package/style-compiler.js

@@ -1,140 +0,0 @@
-import { realpath } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-import { decodeSourceMap } from "./native.js";
-
-const SASS_EXTENSIONS = new Set([".scss", ".sass"]);
-
-export function isSassPath(path) {
-  return SASS_EXTENSIONS.has(extname(path));
-}
-
-export function isPreprocessorPath(path) {
-  return isSassPath(path) || extname(path) === ".less";
-}
-
-async function loadProjectModule(packageRoot, name, errorMessage) {
-  const projectRequire = createRequire(join(packageRoot, "package.json"));
-  let modulePath;
-  try {
-    modulePath = projectRequire.resolve(name);
-  } catch {
-    throw new Error(errorMessage);
-  }
-  const imported = await import(pathToFileURL(modulePath));
-  return imported.default ?? imported;
-}
-
-export function loadProjectSass(packageRoot) {
-  return loadProjectModule(packageRoot, "sass", "Sass must be installed in the target project.");
-}
-
-export function loadProjectLess(packageRoot) {
-  return loadProjectModule(packageRoot, "less", "Less must be installed in the target project.");
-}
-
-export async function compileSassEntry(sass, entryPath, source, { virtualEntry = false } = {}) {
-  const options = {
-    sourceMap: true,
-    sourceMapIncludeSources: true,
-  };
-  const result =
-    source === undefined
-      ? await sass.compileAsync(entryPath, options)
-      : await sass.compileStringAsync(source, {
-          ...options,
-          url: pathToFileURL(entryPath),
-          syntax: extname(entryPath) === ".sass" ? "indented" : "scss",
-        });
-
-  if (!result.sourceMap) throw new Error(`Sass did not produce a source map for ${entryPath}`);
-  const loadedPaths = result.loadedUrls
-    .filter((url) => url.protocol === "file:")
-    .map(fileURLToPath);
-  const mappings = sourceMappings(result.sourceMap);
-  const normalizedPaths = await normalizeEntryPaths(
-    [...loadedPaths, ...mappings.map((mapping) => mapping.sourcePath)],
-    entryPath,
-    virtualEntry,
-  );
-  return {
-    css: result.css,
-    loadedPaths: loadedPaths.map((path) => normalizedPaths.get(path)),
-    sourceMappings: mappings.map((mapping) => ({
-      ...mapping,
-      sourcePath: normalizedPaths.get(mapping.sourcePath),
-    })),
-  };
-}
-
-async function normalizeEntryPaths(paths, entryPath, virtualEntry) {
-  // A virtual SFC block entry never exists on disk; a real entry that
-  // vanished mid-run must keep failing as a source-integrity error.
-  const canonicalEntryPath = virtualEntry ? entryPath : await realpath(entryPath);
-  return new Map(
-    await Promise.all(
-      [...new Set(paths)].map(async (path) => {
-        if (path === entryPath) return [path, path];
-        try {
-          return [path, (await realpath(path)) === canonicalEntryPath ? entryPath : path];
-        } catch {
-          return [path, path];
-        }
-      }),
-    ),
-  );
-}
-
-export async function compileLessEntry(less, entryPath, source) {
-  const result = await less.render(source, {
-    filename: entryPath,
-    sourceMap: {
-      outputSourceFiles: true,
-      sourceMapBasepath: dirname(entryPath),
-      sourceMapOutputFilename: `${basename(entryPath, ".less")}.css`,
-    },
-  });
-  return {
-    css: result.css,
-    loadedPaths: result.imports.map((path) =>
-      isAbsolute(path) ? path : resolve(dirname(entryPath), path),
-    ),
-    sourceMappings: result.map ? sourceMappings(JSON.parse(result.map), dirname(entryPath)) : [],
-  };
-}
-
-export function sourceMappings(sourceMap, sourceBase) {
-  return JSON.parse(decodeSourceMap(JSON.stringify(sourceMap))).flatMap(
-    ({ source, ...mapping }) => {
-      const sourcePath = sourcePathFromMap(
-        sourceReferenceFromMap(source, sourceMap.sourceRoot),
-        sourceBase,
-      );
-      return sourcePath ? [{ ...mapping, sourcePath }] : [];
-    },
-  );
-}
-
-function sourceReferenceFromMap(source, sourceRoot) {
-  if (!sourceRoot) return source;
-  if (isAbsolute(sourceRoot)) return resolve(sourceRoot, source);
-  try {
-    const root = new URL(sourceRoot);
-    root.pathname = `${root.pathname.replace(/\/+$/, "")}/`;
-    return new URL(source, root).href;
-  } catch {
-    return join(sourceRoot, source);
-  }
-}
-
-function sourcePathFromMap(source, sourceBase) {
-  if (isAbsolute(source)) return resolve(source);
-  try {
-    const url = new URL(source);
-    return url.protocol === "file:" ? resolve(fileURLToPath(url)) : undefined;
-  } catch {
-    return sourceBase ? resolve(sourceBase, source) : undefined;
-  }
-}