@plumeria/init 19.1.1

package/dist/source.js

@@ -0,0 +1,413 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readsMember = exports.callsFunction = exports.callsMethod = exports.importedFrom = exports.codeMask = exports.pluginsArrayOf = exports.configObjects = exports.directProperty = exports.moduleKindOf = exports.appendToConfigList = exports.wrapDefaultExport = exports.defaultExportOf = exports.appendInside = exports.appendToCall = exports.appendAtArray = exports.appendToArray = exports.addImport = exports.importsModule = exports.closerOf = void 0;
+const PAIRS = { '(': ')', '[': ']', '{': '}' };
+const endOfString = (source, start) => {
+    const quote = source[start];
+    for (let i = start + 1; i < source.length; i++) {
+        const char = source[i];
+        if (char === '\\') {
+            i++;
+            continue;
+        }
+        if (quote === '`' && char === '$' && source[i + 1] === '{') {
+            const closed = (0, exports.closerOf)(source, i + 1);
+            if (closed === -1)
+                return source.length - 1;
+            i = closed;
+            continue;
+        }
+        if (char === quote)
+            return i;
+    }
+    return source.length - 1;
+};
+const closerOf = (source, open) => {
+    const opener = source[open];
+    const closer = PAIRS[opener];
+    if (!closer)
+        return -1;
+    let depth = 0;
+    for (let i = open; i < source.length; i++) {
+        const char = source[i];
+        if (char === '/' && source[i + 1] === '/') {
+            const line = source.indexOf('\n', i);
+            if (line === -1)
+                return -1;
+            i = line;
+            continue;
+        }
+        if (char === '/' && source[i + 1] === '*') {
+            const end = source.indexOf('*/', i + 2);
+            if (end === -1)
+                return -1;
+            i = end + 1;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            i = endOfString(source, i);
+            continue;
+        }
+        if (char === opener)
+            depth++;
+        else if (char === closer) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+};
+exports.closerOf = closerOf;
+const lineStartOf = (source, index) => source.lastIndexOf('\n', index) + 1;
+const indentOf = (source, index) => {
+    const start = lineStartOf(source, index);
+    return /^[ \t]*/.exec(source.slice(start))[0];
+};
+const importsModule = (source, specifier) => new RegExp(`(from|require\\()\\s*['"]${specifier.replace(/[/@.]/g, '\\$&')}['"]`).test(source);
+exports.importsModule = importsModule;
+const addImport = (source, statement) => {
+    const pattern = /^[ \t]*(?:import\b[^\n]*|(?:const|let|var)\b[^\n]*require\([^\n]*)\n/gm;
+    let end = 0;
+    for (let match = pattern.exec(source); match; match = pattern.exec(source)) {
+        end = match.index + match[0].length;
+    }
+    if (end === 0)
+        return `${statement}\n${source}`;
+    return `${source.slice(0, end)}${statement}\n${source.slice(end)}`;
+};
+exports.addImport = addImport;
+const appendToArray = (source, key, entry) => {
+    const pattern = new RegExp(`\\b${key}\\s*:\\s*\\[`);
+    const match = pattern.exec(source);
+    if (!match)
+        return undefined;
+    return (0, exports.appendAtArray)(source, match.index + match[0].length - 1, entry);
+};
+exports.appendToArray = appendToArray;
+const appendAtArray = (source, open, entry) => {
+    if (source[open] !== '[')
+        return undefined;
+    const close = (0, exports.closerOf)(source, open);
+    if (close === -1)
+        return undefined;
+    const body = source.slice(open + 1, close);
+    if (body.trim() === '') {
+        return `${source.slice(0, open + 1)}${entry}${source.slice(close)}`;
+    }
+    if (!body.includes('\n')) {
+        const trimmed = body.replace(/,\s*$/, '');
+        return `${source.slice(0, open + 1)}${trimmed}, ${entry}${source.slice(close)}`;
+    }
+    const base = indentOf(source, open);
+    const inner = `${base}  `;
+    const trimmed = body.replace(/,?\s*$/, '');
+    return `${source.slice(0, open + 1)}${trimmed},\n${inner}${entry},\n${base}${source.slice(close)}`;
+};
+exports.appendAtArray = appendAtArray;
+const appendToCall = (source, callee, entries) => {
+    const pattern = new RegExp(`\\b${callee}\\s*\\(`);
+    const match = pattern.exec(source);
+    if (!match)
+        return undefined;
+    return (0, exports.appendInside)(source, match.index + match[0].length - 1, entries);
+};
+exports.appendToCall = appendToCall;
+const appendInside = (source, open, entries) => {
+    const close = (0, exports.closerOf)(source, open);
+    if (close === -1)
+        return undefined;
+    const base = indentOf(source, open);
+    const inner = `${base}  `;
+    const trimmed = source.slice(open + 1, close).replace(/,?\s*$/, '');
+    const head = trimmed === '' ? '' : `${trimmed},\n`;
+    const added = entries
+        .map((entry) => entry
+        .split('\n')
+        .map((line) => `${inner}${line}`)
+        .join('\n'))
+        .map((entry) => `${entry},`)
+        .join('\n');
+    return `${source.slice(0, open + 1)}${head}${added}\n${base}${source.slice(close)}`;
+};
+exports.appendInside = appendInside;
+const defaultExportOf = (source) => {
+    const match = /^[ \t]*(export default|module\.exports\s*=)[ \t]*/m.exec(source);
+    if (!match)
+        return undefined;
+    const start = match.index + match[0].length;
+    let depth = 0;
+    let end = source.length;
+    for (let i = start; i < source.length; i++) {
+        const char = source[i];
+        if (char === '"' || char === "'" || char === '`') {
+            i = endOfString(source, i);
+            continue;
+        }
+        if (char === '(' || char === '[' || char === '{') {
+            depth++;
+            continue;
+        }
+        if (char === ')' || char === ']' || char === '}') {
+            depth--;
+            continue;
+        }
+        if (depth === 0 && (char === ';' || char === '\n')) {
+            end = i;
+            break;
+        }
+    }
+    return {
+        keyword: match[1],
+        start,
+        end,
+        expression: source.slice(start, end).trim(),
+    };
+};
+exports.defaultExportOf = defaultExportOf;
+const wrapDefaultExport = (source, wrapper, extra = '') => {
+    const exported = (0, exports.defaultExportOf)(source);
+    if (!exported)
+        return undefined;
+    if (exported.expression.startsWith(`${wrapper}(`))
+        return source;
+    return `${source.slice(0, exported.start)}${wrapper}(${exported.expression}${extra})${source.slice(exported.end)}`;
+};
+exports.wrapDefaultExport = wrapDefaultExport;
+const appendToConfigList = (source, entries) => {
+    const exported = (0, exports.defaultExportOf)(source);
+    if (!exported)
+        return undefined;
+    if (exported.expression.startsWith('[')) {
+        return (0, exports.appendInside)(source, source.indexOf('[', exported.start), entries);
+    }
+    const call = /^([A-Za-z_$][\w$]*)\s*\(/.exec(exported.expression);
+    if (!call)
+        return undefined;
+    return (0, exports.appendToCall)(source, call[1], entries);
+};
+exports.appendToConfigList = appendToConfigList;
+const moduleKindOf = (file, source) => {
+    if (file.endsWith('.cjs'))
+        return 'cjs';
+    if (file.endsWith('.mjs') || file.endsWith('.ts') || file.endsWith('.mts'))
+        return 'esm';
+    if (/^[ \t]*(import\b|export\b)/m.test(source))
+        return 'esm';
+    if (/\brequire\s*\(|\bmodule\.exports\b/.test(source))
+        return 'cjs';
+    return 'esm';
+};
+exports.moduleKindOf = moduleKindOf;
+const directProperty = (source, open, key) => {
+    if (source[open] !== '{')
+        return undefined;
+    const close = (0, exports.closerOf)(source, open);
+    if (close === -1)
+        return undefined;
+    const pattern = new RegExp(`^${key}\\s*:\\s*`);
+    for (let i = open + 1; i < close; i++) {
+        const char = source[i];
+        if (char === '/' && source[i + 1] === '/') {
+            const line = source.indexOf('\n', i);
+            if (line === -1)
+                return undefined;
+            i = line;
+            continue;
+        }
+        if (char === '/' && source[i + 1] === '*') {
+            const end = source.indexOf('*/', i + 2);
+            if (end === -1)
+                return undefined;
+            i = end + 1;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            i = endOfString(source, i);
+            continue;
+        }
+        if (char === '(' || char === '[' || char === '{') {
+            const inner = (0, exports.closerOf)(source, i);
+            if (inner === -1)
+                return undefined;
+            i = inner;
+            continue;
+        }
+        if (/[A-Za-z0-9_$]/.test(source[i - 1] ?? ''))
+            continue;
+        const match = pattern.exec(source.slice(i, close));
+        if (match)
+            return i + match[0].length;
+    }
+    return undefined;
+};
+exports.directProperty = directProperty;
+const configObjects = (source) => {
+    const found = [];
+    const exported = (0, exports.defaultExportOf)(source);
+    if (exported && source[exported.start] === '{')
+        found.push(exported.start);
+    const pattern = /(?:\(|=>)\s*\(?\s*\{/g;
+    for (let match = pattern.exec(source); match; match = pattern.exec(source)) {
+        const at = match.index + match[0].length - 1;
+        if (!found.includes(at))
+            found.push(at);
+    }
+    return found;
+};
+exports.configObjects = configObjects;
+const pluginsArrayOf = (source) => {
+    const objects = (0, exports.configObjects)(source);
+    for (const open of objects) {
+        const at = (0, exports.directProperty)(source, open, 'plugins');
+        if (at !== undefined && source[at] === '[')
+            return at;
+    }
+    for (const open of objects) {
+        const vite = (0, exports.directProperty)(source, open, 'vite');
+        if (vite === undefined || source[vite] !== '{')
+            continue;
+        const at = (0, exports.directProperty)(source, vite, 'plugins');
+        if (at !== undefined && source[at] === '[')
+            return at;
+    }
+    return undefined;
+};
+exports.pluginsArrayOf = pluginsArrayOf;
+const REGEX_AFTER = new Set([
+    'return',
+    'typeof',
+    'case',
+    'in',
+    'of',
+    'new',
+    'delete',
+    'void',
+    'do',
+    'else',
+    'yield',
+    'await',
+]);
+const codeMask = (source) => {
+    const masked = source.split('');
+    const blank = (start, end) => {
+        for (let i = start; i < end; i++) {
+            if (source[i] !== '\n' && source[i] !== '\r')
+                masked[i] = ' ';
+        }
+    };
+    const regexCanStartAfter = (index) => {
+        for (let i = index - 1; i >= 0; i--) {
+            if (/\s/.test(source[i]))
+                continue;
+            if (/[([{,:;=!?&|+\-*%^~<>]/.test(source[i]))
+                return true;
+            if (!/[A-Za-z0-9_$]/.test(source[i]))
+                return false;
+            const word = /[A-Za-z0-9_$]+$/.exec(source.slice(0, i + 1))?.[0] ?? '';
+            return REGEX_AFTER.has(word);
+        }
+        return true;
+    };
+    for (let i = 0; i < source.length; i++) {
+        const char = source[i];
+        if (char === '/' && source[i + 1] === '/') {
+            const end = source.indexOf('\n', i + 2);
+            const close = end === -1 ? source.length : end;
+            blank(i, close);
+            i = close - 1;
+            continue;
+        }
+        if (char === '/' && source[i + 1] === '*') {
+            const end = source.indexOf('*/', i + 2);
+            const close = end === -1 ? source.length : end + 2;
+            blank(i, close);
+            i = close - 1;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            const close = endOfString(source, i);
+            blank(i, close + 1);
+            i = close;
+            continue;
+        }
+        if (char === '/' && regexCanStartAfter(i)) {
+            let close = i + 1;
+            let inClass = false;
+            for (; close < source.length; close++) {
+                if (source[close] === '\\') {
+                    close++;
+                    continue;
+                }
+                if (source[close] === '[')
+                    inClass = true;
+                else if (source[close] === ']')
+                    inClass = false;
+                else if (source[close] === '/' && !inClass) {
+                    close++;
+                    while (/[A-Za-z]/.test(source[close] ?? ''))
+                        close++;
+                    break;
+                }
+                else if (source[close] === '\n' || source[close] === '\r') {
+                    break;
+                }
+            }
+            blank(i, close);
+            i = close - 1;
+        }
+    }
+    return masked.join('');
+};
+exports.codeMask = codeMask;
+const bindingNames = (binding) => {
+    const names = [];
+    const braced = /\{([^}]*)\}/.exec(binding);
+    for (const part of binding.replace(/\{[^}]*\}/g, ' ').split(',')) {
+        const name = /([A-Za-z_$][\w$]*)/.exec(part.replace(/^\s*\*\s*as\s+/, '').replace(/^\s*type\s+/, ''));
+        if (name)
+            names.push(name[1]);
+    }
+    if (braced) {
+        for (const part of braced[1].split(',')) {
+            const pieces = part.trim().split(/\s+as\s+/);
+            const name = /([A-Za-z_$][\w$]*)/.exec(pieces[pieces.length - 1] ?? '');
+            if (name)
+                names.push(name[1]);
+        }
+    }
+    return names;
+};
+const importedFrom = (source, specifier) => {
+    const escaped = specifier.replace(/[/@.]/g, '\\$&');
+    const quoted = `['"]${escaped}['"]`;
+    const patterns = [
+        new RegExp(`\\bimport\\s+([^;'"]*?)\\s+from\\s*${quoted}`, 'g'),
+        new RegExp(`\\b(?:const|let|var)\\s+([^;'"=]*?)\\s*=\\s*require\\(\\s*${quoted}`, 'g'),
+        new RegExp(`\\bimport\\s*()${quoted}`, 'g'),
+    ];
+    const names = [];
+    const cuts = [];
+    const code = (0, exports.codeMask)(source);
+    for (const pattern of patterns) {
+        for (let match = pattern.exec(source); match; match = pattern.exec(source)) {
+            const keyword = /\b(?:import|const|let|var|require)\b/.exec(match[0]);
+            if (!keyword || code[match.index + keyword.index] === ' ')
+                continue;
+            cuts.push([match.index, match.index + match[0].length]);
+            names.push(...bindingNames(match[1] ?? ''));
+        }
+    }
+    let rest = source;
+    for (const [start, end] of cuts.sort((a, b) => b[0] - a[0])) {
+        rest = `${rest.slice(0, start)}${rest.slice(end)}`;
+    }
+    return { names: [...new Set(names)], rest };
+};
+exports.importedFrom = importedFrom;
+const callsMethod = (source, name) => new RegExp(`\\b${name}\\s*\\.\\s*[A-Za-z_$][\\w$]*\\s*\\(`).test((0, exports.codeMask)(source));
+exports.callsMethod = callsMethod;
+const callsFunction = (source, name) => new RegExp(`\\b${name}\\s*\\(`).test((0, exports.codeMask)(source));
+exports.callsFunction = callsFunction;
+const readsMember = (source, name, member) => new RegExp(`\\b${name}\\s*\\.\\s*${member}\\b`).test((0, exports.codeMask)(source));
+exports.readsMember = readsMember;

package/dist/style.d.ts

@@ -0,0 +1,16 @@
+import { styleText } from 'node:util';
+type Format = Parameters<typeof styleText>[0];
+export declare const paint: (stream: NodeJS.WritableStream, format: Format, text: string) => string;
+export declare const style: {
+    ok: (text: string) => string;
+    install: (text: string) => string;
+    write: (text: string) => string;
+    patch: (text: string) => string;
+    manual: (text: string) => string;
+    skip: (text: string) => string;
+    strong: (text: string) => string;
+    faint: (text: string) => string;
+    choice: (text: string) => string;
+    failure: (text: string) => string;
+};
+export {};

package/dist/style.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.style = exports.paint = void 0;
+const node_util_1 = require("node:util");
+const paint = (stream, format, text) => (0, node_util_1.styleText)(format, text, { validateStream: true, stream });
+exports.paint = paint;
+const on = (stream) => (format) => (text) => (0, exports.paint)(stream, format, text);
+const out = on(process.stdout);
+const err = on(process.stderr);
+exports.style = {
+    ok: out('green'),
+    install: out('cyan'),
+    write: out('green'),
+    patch: out('yellow'),
+    manual: out('red'),
+    skip: out('dim'),
+    strong: out('bold'),
+    faint: out('dim'),
+    choice: out(['bold', 'cyan']),
+    failure: err('red'),
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@plumeria/init",
+  "version": "19.1.1",
+  "description": "One command that sets up Plumeria: detects the bundler, installs the packages, writes the configs",
+  "author": "Refirst 11",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/refirst11",
+  "homepage": "https://plumeria.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zss-in-js/plumeria.git",
+    "directory": "packages/init"
+  },
+  "bugs": {
+    "url": "https://github.com/zss-in-js/plumeria/issues"
+  },
+  "keywords": [
+    "plumeria",
+    "init",
+    "setup",
+    "cli",
+    "css-in-js"
+  ],
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "plumeria-init": "bin/init.js"
+  },
+  "files": [
+    "dist/",
+    "bin/"
+  ],
+  "scripts": {
+    "build": "rimraf dist && pnpm cjs",
+    "cjs": "tsc --project tsconfig.cjs.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}