@knighted/css 1.1.0-rc.5 → 1.1.0-rc.7

package/dist/cjs/loaderBridge.cjs

@@ -0,0 +1,470 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__loaderBridgeInternals = exports.pitch = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const loaderInternals_js_1 = require("./loaderInternals.cjs");
+const styleGraph_js_1 = require("./styleGraph.cjs");
+const DEFAULT_EXPORT_NAME = 'knightedCss';
+const BRIDGE_STYLE_EXTENSIONS = ['.css', '.scss', '.sass', '.less', '.css.ts'];
+const loader = function loader(source) {
+    return source;
+};
+const pitch = function pitch(remainingRequest) {
+    const resolvedRemainingRequest = resolveRemainingRequest(this, remainingRequest);
+    if (isJsLikeResource(this.resourcePath) && (0, loaderInternals_js_1.hasCombinedQuery)(this.resourceQuery)) {
+        const callback = getAsyncCallback(this);
+        if (!callback) {
+            return createCombinedJsBridgeModuleSync(resolvedRemainingRequest);
+        }
+        readResourceSource(this)
+            .then(async (source) => {
+            const cssRequests = await collectBridgeStyleRequests(this, source);
+            const upstreamRequest = buildUpstreamRequest(resolvedRemainingRequest);
+            callback(null, createCombinedJsBridgeModule({
+                upstreamRequest: upstreamRequest || '',
+                cssRequests,
+                emitDefault: false,
+            }));
+        })
+            .catch(error => callback(error));
+        return;
+    }
+    const callback = getAsyncCallback(this);
+    if (!callback) {
+        const localsRequest = buildProxyRequest(this);
+        const upstreamRequest = buildUpstreamRequest(resolvedRemainingRequest);
+        const { emitCssModules } = resolveLoaderOptions(this);
+        const combined = (0, loaderInternals_js_1.hasCombinedQuery)(this.resourceQuery);
+        const skipSyntheticDefault = (0, loaderInternals_js_1.hasNamedOnlyQueryFlag)(this.resourceQuery);
+        if ((0, loaderInternals_js_1.hasQueryFlag)(this.resourceQuery, loaderInternals_js_1.TYPES_QUERY_FLAG)) {
+            emitKnightedWarning(this, 'The bridge loader does not generate stableSelectors. Remove the "types" query flag.');
+        }
+        const emitDefault = combined
+            ? (0, loaderInternals_js_1.shouldEmitCombinedDefault)({
+                detection: 'unknown',
+                request: localsRequest,
+                skipSyntheticDefault,
+            })
+            : false;
+        const resolvedUpstream = upstreamRequest || localsRequest;
+        const resolvedLocals = upstreamRequest || localsRequest;
+        return createBridgeModule({
+            localsRequest: resolvedLocals,
+            upstreamRequest: resolvedUpstream,
+            combined,
+            emitDefault,
+            emitCssModules,
+        });
+    }
+    const localsRequest = buildProxyRequest(this);
+    const upstreamRequest = buildUpstreamRequest(resolvedRemainingRequest);
+    const { emitCssModules } = resolveLoaderOptions(this);
+    const combined = (0, loaderInternals_js_1.hasCombinedQuery)(this.resourceQuery);
+    const skipSyntheticDefault = (0, loaderInternals_js_1.hasNamedOnlyQueryFlag)(this.resourceQuery);
+    if ((0, loaderInternals_js_1.hasQueryFlag)(this.resourceQuery, loaderInternals_js_1.TYPES_QUERY_FLAG)) {
+        emitKnightedWarning(this, 'The bridge loader does not generate stableSelectors. Remove the "types" query flag.');
+    }
+    const emitDefault = combined
+        ? (0, loaderInternals_js_1.shouldEmitCombinedDefault)({
+            detection: 'unknown',
+            request: localsRequest,
+            skipSyntheticDefault,
+        })
+        : false;
+    const resolvedUpstream = upstreamRequest || localsRequest;
+    const resolvedLocals = upstreamRequest || localsRequest;
+    const collectSource = isJsLikeResource(this.resourcePath)
+        ? readResourceSource(this)
+        : Promise.resolve(undefined);
+    collectSource
+        .then(async (source) => {
+        const cssRequests = await collectBridgeStyleRequests(this, source);
+        callback(null, createBridgeModule({
+            localsRequest: resolvedLocals,
+            upstreamRequest: resolvedUpstream,
+            combined,
+            emitDefault,
+            emitCssModules,
+            cssRequests,
+        }));
+    })
+        .catch(error => callback(error));
+    return;
+};
+exports.pitch = pitch;
+loader.pitch = exports.pitch;
+exports.default = loader;
+function resolveLoaderOptions(ctx) {
+    const rawOptions = (typeof ctx.getOptions === 'function' ? ctx.getOptions() : {});
+    return {
+        emitCssModules: rawOptions.emitCssModules !== false,
+    };
+}
+function getAsyncCallback(ctx) {
+    return typeof ctx.async === 'function' ? ctx.async() : undefined;
+}
+function readResourceSource(ctx) {
+    return new Promise((resolve, reject) => {
+        ctx.fs.readFile(ctx.resourcePath, (error, data) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            if (!data) {
+                reject(new Error(`Unable to read ${ctx.resourcePath}`));
+                return;
+            }
+            resolve(data.toString('utf8'));
+        });
+    });
+}
+async function collectBridgeStyleRequests(ctx, source) {
+    const graphImports = await collectStyleGraphImports(ctx);
+    const graphPaths = new Set(graphImports.map(filePath => node_path_1.default.resolve(filePath)));
+    const graphRequests = graphImports
+        .filter(filePath => node_path_1.default.resolve(filePath) !== node_path_1.default.resolve(ctx.resourcePath))
+        .map(filePath => buildBridgeCssRequest(filePath));
+    if (!source) {
+        return dedupeRequests(graphRequests);
+    }
+    const directSpecifiers = collectStyleImportSpecifiers(source);
+    const directRequests = directSpecifiers
+        .map(specifier => {
+        const [resource, query] = specifier.split('?');
+        if (query) {
+            return buildBridgeCssRequest(specifier);
+        }
+        const resolved = resolveStyleSpecifier(resource, ctx.resourcePath);
+        if (resolved && graphPaths.has(resolved)) {
+            return undefined;
+        }
+        return buildBridgeCssRequest(specifier);
+    })
+        .filter((request) => Boolean(request));
+    return dedupeRequests([...graphRequests, ...directRequests]);
+}
+async function collectStyleGraphImports(ctx) {
+    const cwd = ctx.rootContext ?? node_path_1.default.dirname(ctx.resourcePath);
+    const filter = (filePath) => !filePath.includes('node_modules');
+    try {
+        return await (0, styleGraph_js_1.collectTransitiveStyleImports)(ctx.resourcePath, {
+            cwd,
+            styleExtensions: BRIDGE_STYLE_EXTENSIONS,
+            filter,
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function resolveStyleSpecifier(specifier, importer) {
+    if (!specifier)
+        return undefined;
+    if (specifier.startsWith('.')) {
+        return node_path_1.default.resolve(node_path_1.default.dirname(importer), specifier);
+    }
+    if (node_path_1.default.isAbsolute(specifier)) {
+        return node_path_1.default.resolve(specifier);
+    }
+    return undefined;
+}
+function dedupeRequests(requests) {
+    const seen = new Set();
+    const output = [];
+    for (const request of requests) {
+        if (seen.has(request))
+            continue;
+        seen.add(request);
+        output.push(request);
+    }
+    return output;
+}
+function collectStyleImportSpecifiers(source) {
+    const matches = new Set();
+    const importPattern = /(?:import|export)\s+(?:[^'"\n]+\s+from\s+)?['"]([^'"\n]+?\.(?:css|scss|sass|less|css\.ts)(?:\?[^'"\n]+)?)['"]/g;
+    let match;
+    while ((match = importPattern.exec(source))) {
+        if (match[1]) {
+            matches.add(match[1]);
+        }
+    }
+    return Array.from(matches);
+}
+function buildBridgeCssRequest(specifier) {
+    if (specifier.includes('knighted-css')) {
+        return specifier;
+    }
+    const [resource, query] = specifier.split('?');
+    if (query) {
+        return `${resource}?${query}&knighted-css`;
+    }
+    return `${specifier}?knighted-css`;
+}
+function createCombinedJsBridgeModuleSync(remainingRequest) {
+    const upstreamRequest = buildUpstreamRequest(remainingRequest);
+    return createCombinedJsBridgeModule({
+        upstreamRequest: upstreamRequest || '',
+        cssRequests: [],
+        emitDefault: false,
+    });
+}
+function createCombinedJsBridgeModule(options) {
+    const upstreamLiteral = JSON.stringify(options.upstreamRequest);
+    const cssImports = options.cssRequests.map((request, index) => {
+        const literal = JSON.stringify(request);
+        return `import * as __knightedStyle${index} from ${literal};`;
+    });
+    const cssValues = options.cssRequests.map((_, index) => `__knightedStyle${index}.knightedCss`);
+    const cssModulesValues = options.cssRequests.map((request, index) => isCssModuleRequest(request)
+        ? `__knightedStyle${index}.knightedCssModules`
+        : 'undefined');
+    const lines = [
+        `import * as __knightedUpstream from ${upstreamLiteral};`,
+        ...cssImports,
+        options.emitDefault
+            ? "const __knightedDefault = Object.prototype.hasOwnProperty.call(__knightedUpstream, 'default') ? __knightedUpstream['default'] : undefined;"
+            : '',
+        `const __knightedCss = [${cssValues.join(', ')}].filter(Boolean).join('\\n');`,
+        `const __knightedCssModules = Object.assign({}, ...[${cssModulesValues.join(', ')}].filter(Boolean));`,
+        `export const ${DEFAULT_EXPORT_NAME} = __knightedCss;`,
+        'export const knightedCssModules = __knightedCssModules;',
+        `export * from ${upstreamLiteral};`,
+    ];
+    if (options.emitDefault) {
+        lines.push('export default __knightedDefault;');
+    }
+    return lines.filter(Boolean).join('\n');
+}
+function isJsLikeResource(resourcePath) {
+    return /\.[cm]?[jt]sx?$/.test(resourcePath);
+}
+function resolveCssText(primary, module) {
+    const candidates = [primary, module, module?.default];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string') {
+            return candidate;
+        }
+        if (candidate &&
+            typeof candidate.toString === 'function') {
+            const text = String(candidate.toString());
+            if (text && text !== '[object Object]' && text !== '[object Module]') {
+                return text;
+            }
+        }
+    }
+    return '';
+}
+function resolveCssModules(primary, module) {
+    const candidates = [primary, module, module?.default];
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== 'object')
+            continue;
+        if (!('locals' in candidate))
+            continue;
+        const locals = candidate.locals;
+        if (!locals || typeof locals !== 'object')
+            continue;
+        return locals;
+    }
+    const isStringMapLocal = (value) => {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return false;
+        return entries.every(([, entry]) => typeof entry === 'string');
+    };
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== 'object')
+            continue;
+        if (isStringMapLocal(candidate))
+            return candidate;
+    }
+    const collectNamedExportsLocal = (value) => {
+        if (!value || typeof value !== 'object')
+            return undefined;
+        const output = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (key === 'default' || key === '__esModule')
+                continue;
+            if (typeof entry === 'string') {
+                output[key] = entry;
+            }
+        }
+        return Object.keys(output).length > 0 ? output : undefined;
+    };
+    return collectNamedExportsLocal(module);
+}
+function createBridgeModule(options) {
+    const localsLiteral = JSON.stringify(options.localsRequest);
+    const upstreamLiteral = JSON.stringify(options.upstreamRequest);
+    const cssRequests = options.cssRequests ?? [];
+    const cssImports = cssRequests.map((request, index) => {
+        const literal = JSON.stringify(request);
+        return `import * as __knightedStyle${index} from ${literal};`;
+    });
+    const cssValues = cssRequests.map((_, index) => `__knightedStyle${index}.knightedCss`);
+    const cssModulesValues = cssRequests.map((request, index) => isCssModuleRequest(request)
+        ? `__knightedStyle${index}.knightedCssModules`
+        : 'undefined');
+    const lines = [
+        `import * as __knightedLocals from ${localsLiteral};`,
+        `import * as __knightedUpstream from ${upstreamLiteral};`,
+        ...cssImports,
+        `const __knightedDefault =\ntypeof __knightedUpstream.default !== 'undefined'\n  ? __knightedUpstream.default\n  : __knightedUpstream;`,
+        `const __knightedResolveCss = ${resolveCssText.toString()};`,
+        `const __knightedResolveCssModules = ${resolveCssModules.toString()};`,
+        `const __knightedUpstreamLocals =\n  __knightedResolveCssModules(__knightedUpstream, __knightedUpstream);`,
+        `const __knightedLocalsExport =\n  __knightedUpstreamLocals ??\n  __knightedResolveCssModules(__knightedLocals, __knightedLocals) ??\n  __knightedLocals;`,
+        `const __knightedBaseCss = __knightedResolveCss(__knightedDefault, __knightedUpstream);`,
+        `const __knightedCss = [__knightedBaseCss, ${cssValues.join(', ')}].filter(Boolean).join('\\n');`,
+        `export const ${DEFAULT_EXPORT_NAME} = __knightedCss;`,
+    ];
+    if (options.emitCssModules) {
+        lines.push(`const __knightedCssModules = Object.assign({}, ...[__knightedLocalsExport ?? __knightedResolveCssModules(\n  __knightedDefault,\n  __knightedUpstream,\n), ${cssModulesValues.join(', ')}].filter(Boolean));`, 'export const knightedCssModules = __knightedCssModules;');
+    }
+    if (options.combined) {
+        lines.push(`export * from ${localsLiteral};`);
+        if (options.emitDefault) {
+            lines.push('export default __knightedLocalsExport;');
+        }
+    }
+    else {
+        lines.push('export default __knightedCss;');
+    }
+    return lines.join('\n');
+}
+function buildUpstreamRequest(remainingRequest) {
+    if (!remainingRequest) {
+        return '';
+    }
+    const request = remainingRequest.startsWith('!')
+        ? remainingRequest
+        : `!!${remainingRequest}`;
+    return request;
+}
+function isCssModuleRequest(request) {
+    const [resource] = request.split('?');
+    const lower = resource.toLowerCase();
+    return /\.module\.(css|scss|sass|less|css\.ts)$/.test(lower);
+}
+function buildProxyRequest(ctx) {
+    const sanitizedQuery = (0, loaderInternals_js_1.buildSanitizedQuery)(ctx.resourceQuery);
+    const rawRequest = getRawRequest(ctx);
+    if (rawRequest) {
+        return rebuildProxyRequestFromRaw(ctx, rawRequest, sanitizedQuery);
+    }
+    const request = `${ctx.resourcePath}${sanitizedQuery}`;
+    return contextifyRequest(ctx, request);
+}
+function resolveRemainingRequest(ctx, remainingRequest) {
+    const resolved = remainingRequest || ctx.remainingRequest;
+    if (resolved)
+        return resolved;
+    const loaders = Array.isArray(ctx.loaders) ? ctx.loaders.slice(ctx.loaderIndex + 1) : [];
+    if (loaders.length > 0) {
+        const loaderRequests = loaders
+            .map(loader => {
+            if (loader && typeof loader.request === 'string' && loader.request) {
+                return loader.request;
+            }
+            const path = loader && typeof loader.path === 'string' ? loader.path : '';
+            const query = loader && typeof loader.query === 'string' ? loader.query : '';
+            return path ? `${path}${query}` : '';
+        })
+            .filter(Boolean);
+        if (loaderRequests.length > 0) {
+            const resource = `${ctx.resourcePath}${ctx.resourceQuery ?? ''}`;
+            return [...loaderRequests, resource].join('!');
+        }
+    }
+    if (typeof ctx.request === 'string' && typeof ctx.loaderIndex === 'number') {
+        const parts = ctx.request.split('!').filter(Boolean);
+        if (parts.length > 0) {
+            const start = Math.min(ctx.loaderIndex + 1, parts.length);
+            const next = parts.slice(start).join('!');
+            if (next)
+                return next;
+        }
+    }
+    return '';
+}
+function rebuildProxyRequestFromRaw(ctx, rawRequest, sanitizedQuery) {
+    const stripped = stripResourceQuery(rawRequest);
+    const loaderDelimiter = stripped.lastIndexOf('!');
+    const loaderPrefix = loaderDelimiter >= 0 ? stripped.slice(0, loaderDelimiter + 1) : '';
+    let resource = loaderDelimiter >= 0 ? stripped.slice(loaderDelimiter + 1) : stripped;
+    if (isRelativeSpecifier(resource)) {
+        resource = makeResourceRelativeToContext(ctx, ctx.resourcePath);
+    }
+    return `${loaderPrefix}${resource}${sanitizedQuery}`;
+}
+function getRawRequest(ctx) {
+    const mod = ctx._module;
+    const request = mod?.rawRequest;
+    if (typeof request === 'string' && request.length > 0) {
+        return request;
+    }
+    return undefined;
+}
+function stripResourceQuery(request) {
+    const idx = request.indexOf('?');
+    return idx >= 0 ? request.slice(0, idx) : request;
+}
+function contextifyRequest(ctx, request) {
+    const context = ctx.context ?? ctx.rootContext ?? process.cwd();
+    if (ctx.utils && typeof ctx.utils.contextify === 'function') {
+        return ctx.utils.contextify(context, request);
+    }
+    return rebuildRelativeRequest(context, request);
+}
+function rebuildRelativeRequest(context, request) {
+    const queryIndex = request.indexOf('?');
+    const resourcePath = queryIndex >= 0 ? request.slice(0, queryIndex) : request;
+    const query = queryIndex >= 0 ? request.slice(queryIndex) : '';
+    const relative = ensureDotPrefixedRelative(node_path_1.default.relative(context, resourcePath), resourcePath);
+    return `${relative}${query}`;
+}
+function makeResourceRelativeToContext(ctx, resourcePath) {
+    const context = ctx.context ?? node_path_1.default.dirname(resourcePath);
+    if (ctx.utils && typeof ctx.utils.contextify === 'function') {
+        const result = ctx.utils.contextify(context, resourcePath);
+        return stripResourceQuery(result);
+    }
+    return ensureDotPrefixedRelative(node_path_1.default.relative(context, resourcePath), resourcePath);
+}
+function ensureDotPrefixedRelative(relativePath, resourcePath) {
+    const fallback = relativePath.length > 0 ? relativePath : node_path_1.default.basename(resourcePath);
+    const normalized = normalizeToPosix(fallback);
+    if (normalized.startsWith('./') || normalized.startsWith('../')) {
+        return normalized;
+    }
+    return `./${normalized}`;
+}
+function normalizeToPosix(filePath) {
+    return filePath.split(node_path_1.default.sep).join('/');
+}
+function isRelativeSpecifier(specifier) {
+    return specifier.startsWith('./') || specifier.startsWith('../');
+}
+function emitKnightedWarning(ctx, message) {
+    const formatted = `\x1b[33m@knighted/css warning\x1b[0m ${message}`;
+    if (typeof ctx.emitWarning === 'function') {
+        ctx.emitWarning(new Error(formatted));
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.warn(formatted);
+}
+exports.__loaderBridgeInternals = {
+    collectStyleImportSpecifiers,
+    buildBridgeCssRequest,
+    createCombinedJsBridgeModule,
+    isJsLikeResource,
+    resolveCssModules,
+    resolveCssText,
+    buildProxyRequest,
+    createBridgeModule,
+};
+//# sourceMappingURL=loaderBridge.cjs.map