@plumeria/utils 21.1.8 → 21.2.1

package/dist/compile.js

@@ -37,6 +37,7 @@ exports.compileCSS = compileCSS;
 const core_1 = require("@swc/core");
 const zss_engine_1 = require("zss-engine");
 const sourceCache_1 = require("./sourceCache");
+const namespaceImport_1 = require("./namespaceImport");
 const parser_1 = require("./parser");
 const path = __importStar(require("path"));
 const rs = __importStar(require("@rust-gear/glob"));
@@ -333,9 +334,18 @@ function compileCSS(options) {
         propsByFile.set(file, entries);
     }
     const processFile = (filePath, writes) => {
-        const scannedTables = readTables(tables, writes);
         const resourcePath = path.resolve(cwd, filePath);
-        const source = options.sources?.[resourcePath] ?? (0, sourceCache_1.readSource)(resourcePath);
+        const written = options.sources?.[resourcePath] ?? (0, sourceCache_1.readSource)(resourcePath);
+        const namespaces = (0, namespaceImport_1.expandNamespaces)(resourcePath, written);
+        try {
+            return extractFile(resourcePath, namespaces?.source ?? written, writes);
+        }
+        catch (error) {
+            throw (0, namespaceImport_1.asWritten)(namespaces, error);
+        }
+    };
+    const extractFile = (resourcePath, source, writes) => {
+        const scannedTables = readTables(tables, writes);
         const extractedSheets = [];
         const ast = (0, core_1.parseSync)(source, {
             syntax: 'typescript',

package/dist/namespaceImport.d.ts

@@ -0,0 +1,18 @@
+export interface NamespaceImport {
+    local: string;
+    start: number;
+    end: number;
+    appendedStart: number;
+    appendedEnd: number;
+    unused: boolean;
+    dots: number[];
+    bindings: string[];
+}
+export interface Namespaces {
+    source: string;
+    originalLength: number;
+    separated: boolean;
+    imports: NamespaceImport[];
+}
+export declare function asWritten<T>(namespaces: Namespaces | undefined, error: T): T;
+export declare function expandNamespaces(filePath: string, source: string): Namespaces | undefined;

package/dist/namespaceImport.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asWritten = asWritten;
+exports.expandNamespaces = expandNamespaces;
+const core_1 = require("@swc/core");
+const ast_1 = require("./ast");
+const parser_1 = require("./parser");
+const references_1 = require("./references");
+const resolver_1 = require("./resolver");
+const NAMESPACE_IMPORT = /import\s*\*\s*as\s+([\p{L}\p{N}_$]+)\s*from\s*(['"])(.*?)\2/gu;
+const cache = new Map();
+const LIMIT = 4096;
+const sameTargets = (a, b) => a.length === b.length &&
+    a.every(([path, actualPath, exports], i) => path === b[i][0] &&
+        actualPath === b[i][1] &&
+        exports.length === b[i][2].length &&
+        exports.every((name, j) => name === b[i][2][j]));
+const NAME = '[\\p{L}\\p{N}_$]';
+function asWritten(namespaces, error) {
+    if (!namespaces)
+        return error;
+    const restore = (text) => {
+        for (const { local, bindings } of namespaces.imports)
+            for (const binding of bindings) {
+                const pattern = new RegExp(`(?<!${NAME})${binding.replace(/\$/g, '\\$')}(?!${NAME})`, 'gu');
+                const dotted = `${local}.${binding.slice(local.length + 1)}`;
+                text = text.replace(pattern, () => dotted);
+            }
+        return text;
+    };
+    if (typeof error === 'string')
+        return restore(error);
+    if (error instanceof Error) {
+        error.message = restore(error.message);
+        if (error.stack)
+            error.stack = restore(error.stack);
+    }
+    return error;
+}
+const unwrap = (node) => {
+    while (node?.type === 'ParenthesisExpression')
+        node = node.expression;
+    return node;
+};
+function expandNamespaces(filePath, source) {
+    const targets = [];
+    for (const [, local, , path] of source.matchAll(NAMESPACE_IMPORT)) {
+        if (path === '@plumeria/core' ||
+            !source.includes(`${local}.`) ||
+            targets.some(([seen]) => seen === path))
+            continue;
+        const actualPath = (0, resolver_1.resolveImportPath)(path, filePath);
+        if (!actualPath)
+            continue;
+        const exports = (0, parser_1.exportNames)(actualPath);
+        if (exports.length > 0)
+            targets.push([path, actualPath, exports]);
+    }
+    if (targets.length === 0)
+        return undefined;
+    const cached = cache.get(filePath);
+    if (cached &&
+        cached.source === source &&
+        sameTargets(cached.targets, targets))
+        return cached.namespaces;
+    const namespaces = expand(source, targets);
+    if (cache.size >= LIMIT)
+        cache.clear();
+    cache.set(filePath, { source, targets, namespaces });
+    return namespaces;
+}
+function expand(source, resolved) {
+    let ast;
+    try {
+        ast = (0, core_1.parseSync)(source, {
+            syntax: 'typescript',
+            tsx: true,
+            target: 'es2022',
+        });
+    }
+    catch {
+        return undefined;
+    }
+    const buffer = Buffer.from(source, 'utf-8');
+    const leadingBytes = Buffer.byteLength(source.slice(0, (0, ast_1.getLeadingCommentLength)(source)), 'utf-8');
+    const base = ast.span.start - leadingBytes;
+    const targets = new Map();
+    for (const statement of ast.body) {
+        if (statement.type !== 'ImportDeclaration' || statement.typeOnly)
+            continue;
+        const specifier = statement.specifiers[0];
+        if (specifier?.type !== 'ImportNamespaceSpecifier')
+            continue;
+        const target = resolved.find(([path]) => path === statement.source.value);
+        if (!target)
+            continue;
+        targets.set(specifier.local.value, {
+            decl: statement,
+            exports: new Set(target[2]),
+        });
+    }
+    if (targets.size === 0)
+        return undefined;
+    const { names: references } = (0, references_1.collectReferenceIdentifiers)(ast, {
+        runtimeReads: true,
+    });
+    const kept = new Set();
+    const found = [];
+    const keyOf = (node) => `${node.span.start}:${node.span.end}`;
+    const keep = (node) => {
+        node = unwrap(node);
+        if (node?.type === 'MemberExpression')
+            kept.add(keyOf(node));
+    };
+    const walk = (n) => {
+        if (!n || typeof n !== 'object')
+            return;
+        if (Array.isArray(n)) {
+            n.forEach(walk);
+            return;
+        }
+        switch (n.type) {
+            case 'CallExpression':
+                keep(n.callee);
+                break;
+            case 'TaggedTemplateExpression':
+                keep(n.tag);
+                break;
+            case 'AssignmentExpression':
+            case 'AssignmentPattern':
+            case 'ForInStatement':
+            case 'ForOfStatement':
+                keep(n.left);
+                break;
+            case 'UpdateExpression':
+            case 'RestElement':
+                keep(n.argument);
+                break;
+            case 'UnaryExpression':
+                if (n.operator === 'delete')
+                    keep(n.argument);
+                break;
+            case 'ArrayPattern':
+                n.elements?.forEach(keep);
+                break;
+            case 'KeyValuePatternProperty':
+                keep(n.value);
+                break;
+            case 'MemberExpression': {
+                const { object, property } = n;
+                const target = object?.type === 'Identifier' ? targets.get(object.value) : undefined;
+                if (target &&
+                    references.get(object.span.start) === object.value &&
+                    property?.type === 'Identifier' &&
+                    target.exports.has(property.value)) {
+                    found.push({
+                        local: object.value,
+                        name: property.value,
+                        object,
+                        key: keyOf(n),
+                    });
+                }
+                break;
+            }
+        }
+        for (const key in n) {
+            if (key === 'span')
+                continue;
+            walk(n[key]);
+        }
+    };
+    ast.body.forEach(walk);
+    const rewritten = new Set();
+    const names = new Map();
+    const dots = new Map();
+    const taken = new Map();
+    const isTaken = (binding) => {
+        let hit = taken.get(binding);
+        if (hit === undefined)
+            taken.set(binding, (hit = source.includes(binding)));
+        return hit;
+    };
+    for (const { local, name, object, key } of found) {
+        const dot = object.span.end - base;
+        if (kept.has(key) ||
+            buffer[dot] !== 0x2e ||
+            buffer.subarray(dot + 1, dot + 1 + Buffer.byteLength(name)).toString() !==
+                name ||
+            isTaken(`${local}$${name}`)) {
+            continue;
+        }
+        buffer[dot] = 0x24;
+        rewritten.add(object.span.start);
+        const list = names.get(local) ?? [];
+        if (!list.includes(name))
+            list.push(name);
+        names.set(local, list);
+        const at = dots.get(local) ?? [];
+        at.push(dot);
+        dots.set(local, at);
+    }
+    if (names.size === 0)
+        return undefined;
+    let output = buffer.toString('utf-8');
+    const originalLength = buffer.length;
+    const separated = !output.endsWith('\n');
+    if (separated)
+        output += '\n';
+    let length = Buffer.byteLength(output);
+    const imports = [];
+    const locals = [...names.keys()].sort((a, b) => targets.get(a).decl.span.start - targets.get(b).decl.span.start);
+    for (const local of locals) {
+        const { decl } = targets.get(local);
+        const raw = buffer
+            .subarray(decl.source.span.start - base, decl.source.span.end - base)
+            .toString('utf-8');
+        const specifiers = names
+            .get(local)
+            .map((name) => `${name} as ${local}$${name}`)
+            .join(', ');
+        const statement = `import { ${specifiers} } from ${raw};`;
+        output += statement;
+        const appendedStart = length;
+        length += Buffer.byteLength(statement);
+        const unused = [...references].every(([start, name]) => name !== local || rewritten.has(start));
+        imports.push({
+            local,
+            start: decl.span.start - base,
+            end: decl.span.end - base,
+            appendedStart,
+            appendedEnd: length,
+            unused,
+            dots: dots.get(local),
+            bindings: names.get(local).map((name) => `${local}$${name}`),
+        });
+    }
+    return { source: output, originalLength, separated, imports };
+}

package/dist/parser.js

@@ -55,6 +55,7 @@ exports.resolveExport = resolveExport;
 exports.extractOndemandStyles = extractOndemandStyles;
 exports.deepMerge = deepMerge;
 const sourceCache_1 = require("./sourceCache");
+const namespaceImport_1 = require("./namespaceImport");
 const createTheme_1 = require("./createTheme");
 const core_1 = require("@swc/core");
 const path = __importStar(require("path"));
@@ -1328,9 +1329,16 @@ function runScan(scanCwd, styleProp) {
     }
     catch {
     }
-    const resolutionChanged = resolutionConfigStamp !== undefined &&
-        resolutionConfigStamp !== configStamp;
-    if (resolutionConfigStamp !== configStamp)
+    const manifestStamp = fs.statSync(path.join(cwd, 'package.json'), {
+        throwIfNoEntry: false,
+    });
+    if (manifestStamp)
+        configStamp += `:${manifestStamp.mtimeMs}`;
+    const packagesStale = (0, resolver_1.sourcePackagesStale)();
+    const resolutionChanged = packagesStale ||
+        (resolutionConfigStamp !== undefined &&
+            resolutionConfigStamp !== configStamp);
+    if (packagesStale || resolutionConfigStamp !== configStamp)
         (0, resolver_1.resetImportResolutionCache)(cwd);
     resolutionConfigStamp = configStamp;
     const segments = cwd.split(path.sep);
@@ -1339,18 +1347,26 @@ function runScan(scanCwd, styleProp) {
         ? cwd
         : segments.slice(0, dependencyDirectory).join(path.sep) ||
             path.parse(cwd).root;
-    const files = rs
-        .globSync(path.join(root, '**/*.{js,jsx,ts,tsx}'), {
-        exclude: [
-            '**/node_modules/**',
-            '**/dist/**',
-            '**/build/**',
-            '**/.next/**',
-        ],
-        cwd: root,
-        sort: true,
-    })
-        .sort();
+    const exclude = [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/.next/**',
+    ];
+    const files = [
+        ...new Set([
+            ...rs.globSync(path.join(root, '**/*.{js,jsx,ts,tsx}'), {
+                exclude,
+                cwd: root,
+                sort: true,
+            }),
+            ...(0, resolver_1.getSourcePackages)()
+                .flatMap(resolver_1.sourceDirsOf)
+                .flatMap((dir) => rs
+                .globSync('**/*.{js,jsx,ts,tsx}', { exclude, cwd: dir })
+                .map((file) => path.join(dir, file))),
+        ]),
+    ].sort();
     const currentFiles = new Set(files);
     const deletedFiles = [];
     for (const fp of knownFiles) {
@@ -1451,6 +1467,7 @@ function runScan(scanCwd, styleProp) {
             stripFileContributions(filePath, cached);
     }
     const parsedFiles = [];
+    const expanded = new Map();
     for (const filePath of uncachedFiles) {
         try {
             const stats = fs.statSync(filePath);
@@ -1478,7 +1495,10 @@ function runScan(scanCwd, styleProp) {
                 };
                 continue;
             }
-            const ast = (0, core_1.parseSync)(source, {
+            const namespaces = (0, namespaceImport_1.expandNamespaces)(filePath, source);
+            if (namespaces)
+                expanded.set(filePath, namespaces);
+            const ast = (0, core_1.parseSync)(namespaces?.source ?? source, {
                 syntax: 'typescript',
                 tsx: true,
                 target: 'es2022',
@@ -1486,7 +1506,7 @@ function runScan(scanCwd, styleProp) {
             parsedFiles.push({ filePath, ast, mtimeMs: stats.mtimeMs });
         }
         catch (e) {
-            recordFileError(filePath, e);
+            recordFileError(filePath, (0, namespaceImport_1.asWritten)(expanded.get(filePath), e));
         }
     }
     const jsxPhaseQueue = [];
@@ -1495,7 +1515,7 @@ function runScan(scanCwd, styleProp) {
             extractAndCacheExports(file.filePath, file.ast, file.mtimeMs);
         }
         catch (error) {
-            recordFileError(file.filePath, error);
+            recordFileError(file.filePath, (0, namespaceImport_1.asWritten)(expanded.get(file.filePath), error));
         }
     }
     const byPath = new Map(parsedFiles.map((file) => [file.filePath, file]));
@@ -1908,7 +1928,7 @@ function runScan(scanCwd, styleProp) {
                 });
             }
             catch (e) {
-                recordFileError(filePath, e);
+                recordFileError(filePath, (0, namespaceImport_1.asWritten)(expanded.get(filePath), e));
             }
         }
     }
@@ -2374,7 +2394,7 @@ function runScan(scanCwd, styleProp) {
             updateDependencyEdges(filePath, prevDependencies, fileCache[filePath].dependencies);
         }
         catch (e) {
-            recordFileError(entry.filePath, e);
+            recordFileError(entry.filePath, (0, namespaceImport_1.asWritten)(expanded.get(entry.filePath), e));
         }
     }
     for (const entry of jsxPhaseQueue) {
@@ -2596,7 +2616,10 @@ function refreshExports(filePath) {
                 tsx: true,
                 target: 'es2022',
             });
+            const known = filePath in fileCache;
             extractAndCacheExports(filePath, ast, stats.mtimeMs);
+            if (!known)
+                fileCache[filePath].mtimeMs = undefined;
         }
     }
     catch (e) {

package/dist/references.d.ts

@@ -2,5 +2,8 @@ import type { Module } from '@swc/core';
 export interface ReferenceIdentifiers {
     references: Set<number>;
     shorthands: Set<number>;
+    names: Map<number, string>;
 }
-export declare function collectReferenceIdentifiers(ast: Module): ReferenceIdentifiers;
+export declare function collectReferenceIdentifiers(ast: Module, { runtimeReads }?: {
+    runtimeReads?: boolean;
+}): ReferenceIdentifiers;

package/dist/references.js

@@ -133,11 +133,27 @@ const collectHoistedNames = (n, out) => {
         collectHoistedNames(n[key], out);
     }
 };
-function collectReferenceIdentifiers(ast) {
+function collectReferenceIdentifiers(ast, { runtimeReads = false } = {}) {
     const references = new Set();
     const shorthands = new Set();
+    const names = new Map();
     const scopes = [];
     const isShadowed = (name) => scopes.some((scope) => scope.has(name));
+    const reference = (ident) => {
+        if (isShadowed(ident.value))
+            return false;
+        references.add(ident.span.start);
+        names.set(ident.span.start, ident.value);
+        return true;
+    };
+    const elementName = (name) => {
+        if (name?.type === 'Identifier' && /^[a-z]/.test(name.value))
+            return;
+        while (name?.type === 'JSXMemberExpression')
+            name = name.object;
+        if (name?.type === 'Identifier')
+            reference(name);
+    };
     const walkPattern = (n) => {
         if (!n || typeof n !== 'object')
             return;
@@ -205,8 +221,7 @@ function collectReferenceIdentifiers(ast) {
         }
         const type = n.type;
         if (type === 'Identifier') {
-            if (!isShadowed(n.value))
-                references.add(n.span.start);
+            reference(n);
             return;
         }
         if (FUNCTION_TYPES.has(type)) {
@@ -214,6 +229,10 @@ function collectReferenceIdentifiers(ast) {
             return;
         }
         switch (type) {
+            case 'ExportNamedDeclaration':
+                if (n.source)
+                    return;
+                break;
             case 'BlockStatement':
                 walkBlock(n, n.stmts);
                 return;
@@ -278,10 +297,8 @@ function collectReferenceIdentifiers(ast) {
             case 'ObjectExpression':
                 n.properties?.forEach((prop) => {
                     if (prop?.type === 'Identifier') {
-                        if (!isShadowed(prop.value)) {
-                            references.add(prop.span.start);
+                        if (reference(prop))
                             shorthands.add(prop.span.start);
-                        }
                         return;
                     }
                     walk(prop);
@@ -306,11 +323,15 @@ function collectReferenceIdentifiers(ast) {
                 const child = n[key];
                 if (child?.type === 'Computed')
                     walk(child);
+                else if (runtimeReads && type === 'JSXOpeningElement')
+                    elementName(child);
+                else if (runtimeReads && type === 'ExportSpecifier' && key === 'orig')
+                    reference(child);
                 continue;
             }
             walk(n[key]);
         }
     }
     ast.body.forEach(walk);
-    return { references, shorthands };
+    return { references, shorthands, names };
 }

package/dist/resolver.d.ts

@@ -1,2 +1,12 @@
+export interface SourcePackage {
+    name: string;
+    dir: string;
+    exports: unknown;
+    linked: string;
+    manifestMtime: number | undefined;
+}
+export declare function sourceDirsOf(pkg: SourcePackage): string[];
+export declare function sourcePackagesStale(): boolean;
 export declare function resetImportResolutionCache(cwd?: string): void;
+export declare function getSourcePackages(): SourcePackage[];
 export declare function resolveImportPath(importPath: string, importerPath: string): string | null;

package/dist/resolver.js

@@ -33,12 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceDirsOf = sourceDirsOf;
+exports.sourcePackagesStale = sourcePackagesStale;
 exports.resetImportResolutionCache = resetImportResolutionCache;
+exports.getSourcePackages = getSourcePackages;
 exports.resolveImportPath = resolveImportPath;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const CONFIG_DIR = '${configDir}';
 let cachedPathsMatcher = undefined;
+let cachedSourcePackages = undefined;
+const SOURCE_CONDITION = 'plumeria';
 function stripComments(text) {
     let out = '';
     let inString = false;
@@ -260,8 +265,141 @@ function loadPathsMatcher(configPath) {
     const patterns = collectPatterns(configPath, new Set());
     return patterns ? buildMatcher(patterns) : null;
 }
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const hasSubpaths = (exports) => isRecord(exports) && Object.keys(exports).some((key) => key.startsWith('.'));
+const sourceTargetOf = (entry) => {
+    if (!isRecord(entry))
+        return null;
+    const target = entry[SOURCE_CONDITION];
+    return typeof target === 'string' ? target : null;
+};
+function sourceTarget(pkg, subpath) {
+    const { exports } = pkg;
+    if (!hasSubpaths(exports))
+        return subpath === '.' ? sourceTargetOf(exports) : null;
+    if (Object.hasOwn(exports, subpath))
+        return sourceTargetOf(exports[subpath]);
+    let best = null;
+    for (const key of Object.keys(exports)) {
+        const star = key.indexOf('*');
+        if (star < 0 || key.indexOf('*', star + 1) >= 0)
+            continue;
+        const suffix = key.slice(star + 1);
+        if (subpath.length < key.length ||
+            !subpath.startsWith(key.slice(0, star)) ||
+            !subpath.endsWith(suffix))
+            continue;
+        if (best &&
+            (star < best.star ||
+                (star === best.star && key.length <= best.key.length)))
+            continue;
+        best = {
+            key,
+            star,
+            matched: subpath.slice(star, subpath.length - suffix.length),
+        };
+    }
+    if (!best)
+        return null;
+    const target = sourceTargetOf(exports[best.key]);
+    return target === null ? null : target.replaceAll('*', best.matched);
+}
+const sourceDirOf = (dir, target) => {
+    const star = target.indexOf('*');
+    if (star < 0)
+        return path.dirname(path.resolve(dir, target));
+    const base = target.slice(0, star);
+    return base.endsWith('/')
+        ? path.resolve(dir, base)
+        : path.dirname(path.resolve(dir, base));
+};
+function sourceDirsOf(pkg) {
+    const entries = hasSubpaths(pkg.exports)
+        ? Object.values(pkg.exports)
+        : [pkg.exports];
+    const dirs = [
+        ...new Set(entries
+            .map(sourceTargetOf)
+            .filter((target) => target !== null)
+            .map((target) => sourceDirOf(pkg.dir, target))
+            .filter((dir) => dir === pkg.dir || dir.startsWith(pkg.dir + path.sep))),
+    ].sort();
+    return dirs.filter((dir) => !dirs.some((other) => other !== dir && dir.startsWith(other + path.sep)));
+}
+const manifestMtimeOf = (dir) => fs.statSync(path.join(dir, 'package.json'), { throwIfNoEntry: false })
+    ?.mtimeMs;
+const realpathOf = (linked) => {
+    try {
+        return fs.realpathSync(linked);
+    }
+    catch {
+        return null;
+    }
+};
+function sourcePackagesStale() {
+    return (cachedSourcePackages?.some((pkg) => realpathOf(pkg.linked) !== pkg.dir ||
+        manifestMtimeOf(pkg.dir) !== pkg.manifestMtime) ?? false);
+}
+function loadSourcePackages(cwd) {
+    const manifest = readConfig(path.join(cwd, 'package.json'));
+    if (!manifest)
+        return [];
+    const names = [
+        ...new Set([
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ].flatMap((field) => isRecord(manifest[field]) ? Object.keys(manifest[field]) : [])),
+    ].sort();
+    const packages = [];
+    for (const name of names) {
+        let linked = null;
+        for (let dir = cwd;; dir = path.dirname(dir)) {
+            const candidate = path.join(dir, 'node_modules', name);
+            if (fs.statSync(candidate, { throwIfNoEntry: false })?.isDirectory()) {
+                linked = candidate;
+                break;
+            }
+            if (dir === path.dirname(dir))
+                break;
+        }
+        if (!linked)
+            continue;
+        const dir = fs.realpathSync(linked);
+        const exports = readConfig(path.join(dir, 'package.json'))?.exports;
+        if (exports === undefined)
+            continue;
+        const pkg = {
+            name,
+            dir,
+            exports,
+            linked,
+            manifestMtime: manifestMtimeOf(dir),
+        };
+        if (sourceDirsOf(pkg).length > 0)
+            packages.push(pkg);
+    }
+    return packages;
+}
 function resetImportResolutionCache(cwd = process.cwd()) {
     cachedPathsMatcher = loadPathsMatcher(path.join(cwd, 'tsconfig.json'));
+    cachedSourcePackages = loadSourcePackages(cwd);
+}
+function getSourcePackages() {
+    cachedSourcePackages ??= loadSourcePackages(process.cwd());
+    return cachedSourcePackages;
+}
+function resolveSourcePackage(importPath) {
+    const name = packageNameOf(importPath);
+    const pkg = getSourcePackages().find((p) => p.name === name);
+    if (!pkg)
+        return null;
+    const target = sourceTarget(pkg, `.${importPath.slice(name.length)}`);
+    if (target === null)
+        return null;
+    const resolved = path.resolve(pkg.dir, target);
+    return isFile(resolved) ? resolved : null;
 }
 function getPathsMatcher() {
     if (cachedPathsMatcher !== undefined)
@@ -319,6 +457,9 @@ function resolveImportPath(importPath, importerPath) {
                 return result;
         }
     }
+    const sourcePackage = resolveSourcePackage(importPath);
+    if (sourcePackage)
+        return sourcePackage;
     let currentDir = path.dirname(importerPath);
     while (currentDir !== path.parse(currentDir).root) {
         if (fs.existsSync(path.join(currentDir, 'package.json'))) {

package/dist/transform.js

@@ -82,6 +82,7 @@ const createTheme_1 = require("./createTheme");
 const resolver_1 = require("./resolver");
 const ast_1 = require("./ast");
 const references_1 = require("./references");
+const namespaceImport_1 = require("./namespaceImport");
 const propertyPolicy_1 = require("./propertyPolicy");
 const unwrapExport = (node) => {
     if (node?.type === 'ExportDeclaration')
@@ -182,9 +183,21 @@ const foldDynamicVars = (vars) => {
     });
 };
 const transformSource = async (env) => {
-    const { source, root, styleProp, propertyPolicy, isDev, addDependency } = env;
+    const scannedTables = (0, parser_1.scanOverlay)(undefined, env.styleProp);
+    const namespaces = (0, namespaceImport_1.expandNamespaces)(env.moduleId, env.source);
+    try {
+        return await transformExpanded(env, scannedTables, namespaces);
+    }
+    catch (error) {
+        throw (0, namespaceImport_1.asWritten)(namespaces, error);
+    }
+};
+exports.transformSource = transformSource;
+const transformExpanded = async (env, scannedTables, namespaces) => {
+    const { root, styleProp, propertyPolicy, isDev, addDependency } = env;
     const classProp = env.classProp ?? 'className';
     const id = env.moduleId;
+    const source = namespaces?.source ?? env.source;
     const resourcePath = env.moduleId;
     const baseId = env.filePath;
     const ast = (0, core_1.parseSync)(source, {
@@ -244,12 +257,13 @@ const transformSource = async (env) => {
             }
         }
     };
-    const scannedTables = (0, parser_1.scanOverlay)(undefined, styleProp);
     const ownFailure = (0, parser_1.resolveFileError)(baseId, '');
     if (ownFailure)
         throwCompilationError(`[plumeria] ${ownFailure.message}`);
+    const appended = namespaces?.originalLength ?? Infinity;
     for (const node of ast.body) {
-        if (node.type === 'ImportDeclaration') {
+        if (node.type === 'ImportDeclaration' &&
+            node.span.start - baseByteOffset < appended) {
             const sourcePath = node.source.value;
             const actualPath = (0, resolver_1.resolveImportPath)(sourcePath, id);
             if (actualPath) {
@@ -2685,17 +2699,109 @@ const transformSource = async (env) => {
         for (const replacement of replacements)
             replacement.content = replacement.content.replaceAll(deferred.token, content);
     }
-    let offset = 0;
-    const parts = [];
-    replacements.forEach((r) => {
-        if (r.start < offset)
-            return;
-        parts.push(sourceBuffer.subarray(offset, r.start));
-        parts.push(Buffer.from(r.content));
-        offset = r.end;
+    const splice = (list) => {
+        let offset = 0;
+        const parts = [];
+        list.forEach((r) => {
+            if (r.start < offset)
+                return;
+            parts.push(sourceBuffer.subarray(offset, r.start));
+            parts.push(Buffer.from(r.content));
+            offset = r.end;
+        });
+        parts.push(sourceBuffer.subarray(offset));
+        return Buffer.concat(parts).toString();
+    };
+    const transformedSource = splice(replacements);
+    const elided = elidedImports(ast, baseByteOffset, replacements, transformedSource);
+    if (namespaces)
+        namespaceElisions(namespaces, replacements, elided, splice);
+    if (elided.length === 0)
+        return { code: transformedSource };
+    replacements.push(...elided);
+    replacements.sort((a, b) => a.start - b.start || b.end - a.end);
+    return { code: splice(replacements) };
+};
+const namespaceElisions = (namespaces, replacements, elided, splice) => {
+    const covered = (at) => replacements.some((r) => r.start <= at && at < r.end);
+    const removed = ({ appendedStart }) => elided.some((r) => r.start === appendedStart);
+    const appended = ({ appendedStart, appendedEnd }) => ({
+        start: appendedStart,
+        end: appendedEnd,
+        content: '',
     });
-    parts.push(sourceBuffer.subarray(offset));
-    const transformedSource = Buffer.concat(parts).toString();
-    return { code: transformedSource };
+    const extra = [];
+    for (const namespace of namespaces.imports) {
+        if (removed(namespace)) {
+            if (namespace.unused)
+                extra.push({ start: namespace.start, end: namespace.end, content: '' });
+            continue;
+        }
+        for (const dot of namespace.dots)
+            if (!covered(dot))
+                extra.push({ start: dot, end: dot + 1, content: '.' });
+    }
+    const pending = namespaces.imports.filter((namespace) => !removed(namespace));
+    const draft = splice([...replacements, ...elided, ...extra, ...pending.map(appended)].sort((a, b) => a.start - b.start || b.end - a.end));
+    let kept = false;
+    for (const namespace of pending) {
+        if (namespace.bindings.some((binding) => draft.includes(binding)))
+            kept = true;
+        else
+            extra.push(appended(namespace));
+    }
+    elided.push(...extra);
+    if (!kept && namespaces.separated) {
+        const first = namespaces.imports[0].appendedStart;
+        for (const replacement of elided)
+            if (replacement.start === first)
+                replacement.start = namespaces.originalLength;
+    }
+};
+const elidedImports = (ast, baseByteOffset, replacements, transformedSource) => {
+    if (replacements.length === 0)
+        return [];
+    const overlaps = (start, end) => replacements.some((r) => r.start <= end && r.end >= start);
+    const covered = (position) => replacements.some((r) => r.start <= position && r.end > position);
+    const imports = ast.body.filter((statement) => statement.type === 'ImportDeclaration' &&
+        !statement.typeOnly &&
+        statement.specifiers.length > 0 &&
+        statement.specifiers.every((specifier) => specifier.type !== 'ImportSpecifier' || !specifier.isTypeOnly) &&
+        !overlaps(statement.span.start - baseByteOffset, statement.span.end - baseByteOffset));
+    if (imports.length === 0)
+        return [];
+    const positionsOf = new Map();
+    const { names } = (0, references_1.collectReferenceIdentifiers)(ast, { runtimeReads: true });
+    for (const [start, name] of names) {
+        const positions = positionsOf.get(name);
+        if (positions)
+            positions.push(start - baseByteOffset);
+        else
+            positionsOf.set(name, [start - baseByteOffset]);
+    }
+    const candidates = imports.filter((node) => node.specifiers.every(({ local }) => {
+        const positions = positionsOf.get(local.value);
+        return positions !== undefined && positions.every(covered);
+    }));
+    if (candidates.length === 0)
+        return [];
+    let output;
+    try {
+        output = (0, core_1.parseSync)(transformedSource, {
+            syntax: 'typescript',
+            tsx: true,
+            target: 'es2022',
+        });
+    }
+    catch {
+        return [];
+    }
+    const remaining = new Set((0, references_1.collectReferenceIdentifiers)(output, { runtimeReads: true }).names.values());
+    return candidates
+        .filter((node) => node.specifiers.every(({ local }) => !remaining.has(local.value)))
+        .map((node) => ({
+        start: node.span.start - baseByteOffset,
+        end: node.span.end - baseByteOffset,
+        content: '',
+    }));
 };
-exports.transformSource = transformSource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/utils",
-  "version": "21.1.8",
+  "version": "21.2.1",
   "description": "Plumeria Utils",
   "author": "Refirst 11",
   "license": "MIT",