next-with-linaria/lib/loaders/webpack-transform-loader.js

Linaria support for Next.js App Router

"use strict";
var __rest = (this && this.__rest) || function (s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const node_zlib_1 = __importDefault(require("node:zlib"));
const transform_1 = require("@wyw-in-js/transform");
const path_1 = __importDefault(require("path"));
const fast_check_1 = require("../utils/fast-check");
const insert_import_1 = require("../utils/insert-import");
const source_map_1 = require("../utils/source-map");
const consts_1 = require("./consts");
const cache = new transform_1.TransformCacheCollection();
const webpackTransformLoader = function (content, inputSourceMap) {
    this.async();
    const _a = this.getOptions() || {}, { fastCheck = true } = _a, pluginOptions = __rest(_a, ["fastCheck"]);
    const contentStr = content.toString();
    if (!(0, fast_check_1.performFastCheck)(contentStr, fastCheck)) {
        this.callback(null, contentStr, inputSourceMap);
        return;
    }
    const asyncResolve = (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));
        return new Promise((resolve, reject) => {
            this.resolve(context, token, (err, result) => {
                if (err) {
                    console.error(err);
                    reject(err);
                }
                else if (result) {
                    this.addDependency(result);
                    resolve(result);
                }
                else {
                    reject(new Error(`Cannot resolve ${token}`));
                }
            });
        });
    };
    const filename = path_1.default.basename(this.resourcePath, path_1.default.extname(this.resourcePath));
    const transformServices = {
        options: {
            filename: this.resourcePath,
            inputSourceMap: (0, source_map_1.convertSourceMap)(inputSourceMap, this.resourcePath),
            root: process.cwd(),
            pluginOptions,
        },
        cache,
    };
    (0, transform_1.transform)(transformServices, contentStr, asyncResolve).then(async (result) => {
        var _a, _b, _c, _d;
        if (result.cssText) {
            const { cssText } = result;
            await Promise.all((_b = (_a = result.dependencies) === null || _a === void 0 ? void 0 : _a.map((dep) => {
                return asyncResolve(dep, this.resourcePath);
            })) !== null && _b !== void 0 ? _b : []);
            try {
                const compressedCss = node_zlib_1.default.gzipSync(cssText);
                const encodedCss = Buffer.from(compressedCss).toString('base64');
                const isGlobalStyle = filename.endsWith(consts_1.LINARIA_GLOBAL_EXTENSION);
                const cssSuffix = isGlobalStyle
                    ? `${consts_1.LINARIA_GLOBAL_EXTENSION}.css`
                    : `${consts_1.LINARIA_MODULE_EXTENSION}.css`;
                const cssFilename = `${filename}${cssSuffix}`;
                const importStatement = `import "./${cssFilename}!=!./${filename}?./${cssFilename}?css=${encodedCss}"`;
                const finalCode = (0, insert_import_1.insertImportStatement)(result.code, importStatement);
                this.callback(null, finalCode, (_c = result.sourceMap) !== null && _c !== void 0 ? _c : undefined);
            }
            catch (err) {
                this.callback(err);
            }
            return;
        }
        this.callback(null, result.code, (_d = result.sourceMap) !== null && _d !== void 0 ? _d : undefined);
    }, (err) => this.callback(err));
};
exports.default = webpackTransformLoader;
//# sourceMappingURL=webpack-transform-loader.js.map