@wyw-in-js/turbopack-loader 1.0.0

package/types/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const shared_1 = require("@wyw-in-js/shared");
+const transform_1 = require("@wyw-in-js/transform");
+const css_modules_1 = require("./css-modules");
+const file_utils_1 = require("./file-utils");
+const insert_import_1 = require("./insert-import");
+const DEFAULT_EXTENSION = '.wyw-in-js.module.css';
+const stripQueryAndHash = (request) => {
+    const queryIdx = request.indexOf('?');
+    const hashIdx = request.indexOf('#');
+    if (queryIdx === -1) {
+        return hashIdx === -1 ? request : request.slice(0, hashIdx);
+    }
+    if (hashIdx === -1)
+        return request.slice(0, queryIdx);
+    return request.slice(0, Math.min(queryIdx, hashIdx));
+};
+const cache = new transform_1.TransformCacheCollection();
+function convertSourceMap(value, filename) {
+    if (typeof value === 'string' || !value) {
+        return undefined;
+    }
+    return {
+        ...value,
+        file: value.file ?? filename,
+        mappings: value.mappings ?? '',
+        names: value.names ?? [],
+        sources: value.sources ?? [],
+        version: value.version ?? 3,
+    };
+}
+async function resolveWith(resolve, context, request) {
+    if (typeof resolve !== 'function')
+        return false;
+    if (resolve.length >= 3) {
+        return new Promise((ok, fail) => {
+            resolve(context, request, (err, result) => {
+                if (err)
+                    fail(err);
+                else
+                    ok(result ?? false);
+            });
+        });
+    }
+    return resolve(context, request);
+}
+const turbopackLoader = function turbopackLoader(content, inputSourceMap) {
+    const callbackFromAsync = typeof this.async === 'function' ? this.async() : undefined;
+    const callback = typeof callbackFromAsync === 'function' ? callbackFromAsync : this.callback;
+    if (typeof callback !== 'function') {
+        throw new Error('Async loader callback is not available');
+    }
+    (0, shared_1.logger)('turbopack-loader %s', this.resourcePath);
+    const { sourceMap, keepComments, prefixer, configFile, ...rest } = this.getOptions() || {};
+    if (configFile) {
+        const configPath = path_1.default.isAbsolute(configFile)
+            ? configFile
+            : path_1.default.join(process.cwd(), configFile);
+        this.addDependency(configPath);
+    }
+    const cssFileName = `${path_1.default.basename(this.resourcePath, path_1.default.extname(this.resourcePath))}${DEFAULT_EXTENSION}`;
+    const cssFilePath = path_1.default.join(path_1.default.dirname(this.resourcePath), cssFileName);
+    const cssImportPath = `./${cssFileName}`;
+    const resolveModule = this.getResolve({ dependencyType: 'esm' });
+    const asyncResolve = async (token, importer) => {
+        const context = path_1.default.isAbsolute(importer)
+            ? path_1.default.dirname(importer)
+            : path_1.default.join(process.cwd(), path_1.default.dirname(importer));
+        const result = await resolveWith(resolveModule, context, token);
+        if (!result) {
+            throw new Error(`Cannot resolve ${token} from ${context}`);
+        }
+        const filePath = stripQueryAndHash(result);
+        if (path_1.default.isAbsolute(filePath)) {
+            this.addDependency(filePath);
+        }
+        return result;
+    };
+    const transformServices = {
+        options: {
+            filename: this.resourcePath,
+            inputSourceMap: convertSourceMap(inputSourceMap, this.resourcePath),
+            pluginOptions: { configFile, ...rest },
+            prefixer,
+            keepComments,
+            root: process.cwd(),
+        },
+        cache,
+        emitWarning: (message) => {
+            if (typeof this.emitWarning === 'function') {
+                this.emitWarning(new Error(message));
+            }
+        },
+    };
+    (0, transform_1.transform)(transformServices, content.toString(), asyncResolve)
+        .then(async (result) => {
+        const rawCssText = result.cssText ?? '';
+        if (rawCssText.trim()) {
+            let cssText = (0, css_modules_1.makeCssModuleGlobal)(rawCssText);
+            if (sourceMap && typeof result.cssSourceMapText !== 'undefined') {
+                cssText += `\n/*# sourceMappingURL=data:application/json;base64,${Buffer.from(result.cssSourceMapText).toString('base64')}*/\n`;
+            }
+            await Promise.all((result.dependencies ?? []).map((dep) => asyncResolve(dep, this.resourcePath)));
+            (0, file_utils_1.writeFileIfChanged)(cssFilePath, cssText);
+            const importStatement = `import ${JSON.stringify(cssImportPath)};`;
+            const finalCode = (0, insert_import_1.insertImportStatement)(result.code, importStatement);
+            callback(null, finalCode, result.sourceMap ?? undefined);
+            return;
+        }
+        if (fs_1.default.existsSync(cssFilePath)) {
+            (0, file_utils_1.writeFileIfChanged)(cssFilePath, '');
+        }
+        callback(null, result.code, result.sourceMap ?? undefined);
+    })
+        .catch((err) => callback(err));
+};
+exports.default = turbopackLoader;

package/types/insert-import.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Insert an import statement in a safe position:
+ * - after the last existing import declaration,
+ * - otherwise after the directive prologue (e.g. 'use client'),
+ * - otherwise at the top of the file.
+ */
+export declare function insertImportStatement(code: string, importStatement: string): string;

package/types/insert-import.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertImportStatement = insertImportStatement;
+/**
+ * Insert an import statement in a safe position:
+ * - after the last existing import declaration,
+ * - otherwise after the directive prologue (e.g. 'use client'),
+ * - otherwise at the top of the file.
+ */
+function insertImportStatement(code, importStatement) {
+    if (code.includes(importStatement)) {
+        return code;
+    }
+    const importRegex = /^\s*(?:import\s+[^;]+?\s+from\s+["'][^"']+["'];|import\s*["'][^"']+["'];)/gm;
+    const importMatches = [...code.matchAll(importRegex)];
+    if (importMatches.length > 0) {
+        const lastImport = importMatches[importMatches.length - 1];
+        const insertPosition = lastImport.index + lastImport[0].length;
+        return `${code.slice(0, insertPosition)}\n${importStatement}${code.slice(insertPosition)}`;
+    }
+    const directiveRegex = /^(?:(?:\s*["']use \w+["'];?\s*\n?)+)/;
+    const directiveMatch = code.match(directiveRegex);
+    if (directiveMatch) {
+        const endOfDirectives = directiveMatch[0].length;
+        const needsNewline = !code.slice(0, endOfDirectives).endsWith('\n');
+        const separator = needsNewline ? '\n' : '';
+        return `${code.slice(0, endOfDirectives)}${separator}${importStatement}\n${code.slice(endOfDirectives)}`;
+    }
+    return `${importStatement}\n${code}`;
+}