rimecms 0.31.5 → 0.32.0

package/dist/core/dev/cli/generate/index.server.js

@@ -1,98 +0,0 @@
-import { RIME_DEV_CACHE_DIR } from '../../../constant.server.js';
-import cache from '../../cache/index.server.js';
-import { sanitize } from '../../generate/sanitize/index.server.js';
-import { ensureGeneratedConfig, ensureUserConfigExist } from '../../../ensure.server.js';
-import { regenerateModulesDeclaration } from '../../vite/index.server.js';
-import { logger } from '../../../logger/index.server.js';
-import { trycatch } from '../../../../util/function.js';
-import { mkdirSync, rmSync } from 'fs';
-import path from 'path';
-export const generate = async (args) => {
-    const { force } = args;
-    /**
-     * Clear the cached .rime folder
-     */
-    function clearConfigCache() {
-        try {
-            rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
-            mkdirSync(RIME_DEV_CACHE_DIR);
-        }
-        catch (err) {
-            logger.error(err.message);
-        }
-    }
-    /*
-     * Delete routes/(rime) folder
-     */
-    function clearRoutes() {
-        try {
-            rmSync(path.join(process.cwd(), 'src', 'routes', '(rime)'), { recursive: true, force: true });
-        }
-        catch (err) {
-            logger.error(err.message);
-        }
-    }
-    /**
-     * Sanitize the user config and create the config.generated folder
-     */
-    async function sanitizeConfig() {
-        await sanitize();
-    }
-    /**
-     * Create the vite devServer
-     */
-    async function createServer() {
-        const { createServer } = await import('vite');
-        // Create a Vite server using the project's vite.config.ts
-        const vite = await createServer({
-            configFile: path.join(process.cwd(), 'vite.config.ts'),
-            server: {
-                hmr: false,
-                middlewareMode: true
-            },
-            optimizeDeps: { disabled: true },
-            appType: 'custom',
-            logLevel: 'error'
-        });
-        return vite;
-    }
-    async function run() {
-        if (force) {
-            clearConfigCache();
-            clearRoutes();
-        }
-        // Mark that a CLI generation is in flight, so a concurrently running dev
-        // server doesn't race us on the shared .rime cache (see rime.server.ts).
-        process.env.RIME_CLI = 'true';
-        cache.set('.cli', new Date().toISOString());
-        try {
-            ensureUserConfigExist();
-            await sanitizeConfig();
-            // Normal `vite dev` writes this from `configureServer`'s `listening` event, which never
-            // fires here — this command's own Vite server runs in `middlewareMode` (no `httpServer`).
-            regenerateModulesDeclaration();
-            const importPathJS = ensureGeneratedConfig();
-            logger.info('Starting vite server...');
-            const vite = await createServer();
-            try {
-                const mod = await vite.ssrLoadModule(importPathJS);
-                // The generated config's default export is the createRime() promise;
-                // ssrLoadModule only awaits the module's synchronous evaluation, so we
-                // must await it directly to observe init failures (e.g. config validation).
-                await mod.default;
-                logger.info('[✓] Generation completed successfully');
-            }
-            finally {
-                await vite.close();
-            }
-        }
-        finally {
-            cache.delete('.cli');
-        }
-    }
-    const [error] = await trycatch(run);
-    if (error) {
-        logger.error('[✗] Error during generation:', error);
-        throw error;
-    }
-};

package/dist/core/dev/cli/generate-manifest/index.server.d.ts

@@ -1,17 +0,0 @@
-/**
- * Run at prepack, after `svelte-package` (operates on the compiled `dist/`, not `src/lib`) —
- * makes this package's own `$rime/modules` splits consumable by anyone who installs it:
- *
- * 1. Builds an export-name → split index from every module.(server.)js pair under `dist/`,
- *    validating it as it goes (see `buildModuleIndex` below) — a name that resolves
- *    ambiguously has no correct rewrite target in step 2, so this has to fail loudly here,
- *    not silently later.
- * 2. AST-rewrites every `import ... from '$rime/modules'` found anywhere under `dist/` into
- *    one `import ... from '$rime/modules/<pkg>/<subpath>'` per split it actually draws from —
- *    the bare barrel form never survives past this step.
- * 3. Writes `dist/.rime-modules.json` (subpath → real file paths, read directly by a
- *    consumer's Vite plugin — no fs.existsSync probing, no guessing) and
- *    `dist/.rime-modules.d.ts` (one `declare module '$rime/modules/<pkg>/<subpath>'` per
- *    split, referenced by a consumer's generated types).
- */
-export declare const generateManifest: () => void;

package/dist/core/dev/cli/generate-manifest/index.server.js

@@ -1,221 +0,0 @@
-import { generate } from '@babel/generator';
-import * as t from '@babel/types';
-import { babelParse } from 'ast-kit';
-import fs from 'node:fs';
-import path from 'node:path';
-import { logger } from '../../../logger/index.server.js';
-import { scanModulePairs } from '../../generate/runtime/index.server.js';
-import { parseExportNames } from '../../generate/runtime/parse-exports.server.js';
-import { getPackageInfoByKey } from '../util/package.server.js';
-/**
- * Run at prepack, after `svelte-package` (operates on the compiled `dist/`, not `src/lib`) —
- * makes this package's own `$rime/modules` splits consumable by anyone who installs it:
- *
- * 1. Builds an export-name → split index from every module.(server.)js pair under `dist/`,
- *    validating it as it goes (see `buildModuleIndex` below) — a name that resolves
- *    ambiguously has no correct rewrite target in step 2, so this has to fail loudly here,
- *    not silently later.
- * 2. AST-rewrites every `import ... from '$rime/modules'` found anywhere under `dist/` into
- *    one `import ... from '$rime/modules/<pkg>/<subpath>'` per split it actually draws from —
- *    the bare barrel form never survives past this step.
- * 3. Writes `dist/.rime-modules.json` (subpath → real file paths, read directly by a
- *    consumer's Vite plugin — no fs.existsSync probing, no guessing) and
- *    `dist/.rime-modules.d.ts` (one `declare module '$rime/modules/<pkg>/<subpath>'` per
- *    split, referenced by a consumer's generated types).
- */
-export const generateManifest = () => {
-    const pkgName = getPackageInfoByKey('name');
-    if (!pkgName) {
-        throw new Error("$rime generate-manifest: could not read this package's own name from package.json");
-    }
-    const distDir = path.resolve(process.cwd(), 'dist');
-    if (!fs.existsSync(distDir)) {
-        throw new Error(`$rime generate-manifest: no dist/ at ${distDir} — run this after svelte-package, not before`);
-    }
-    const pairs = scanModulePairs(distDir);
-    const nameOwner = buildModuleIndex(pairs);
-    rewriteBarrelImports(distDir, pkgName, nameOwner);
-    writeManifest(distDir, pkgName, pairs);
-    logger.info(`[✓] $rime/modules manifest generated for ${pkgName} (${pairs.size} split(s))`);
-};
-/**
- * Export-name → split index, with the two collision scenarios from the design doc handled
- * distinctly:
- * - module.ts and module.server.ts of the *same* split sharing a name — not a collision, that's
- *   the whole point of a pair (skip, both sides collapse to one entry). The two sides don't
- *   need to export the *same set* of names either — a server-only helper the client build
- *   never needs (e.g. cache's own `toHash`) is completely normal, not a broken pair; indexed
- *   from the union of both sides, worth a log for visibility, never a blocking error.
- * - two *different* splits exporting the same name — the actual collision. An ambiguous
- *   `$rime/modules` import has no correct rewrite target, so this is a hard error here, not a
- *   warning: it has to be caught before the rewrite runs, not after.
- */
-function buildModuleIndex(pairs) {
-    const nameOwner = new Map();
-    for (const [subpath, entry] of pairs) {
-        const serverNames = entry.server ? parseExportNames(entry.server) : [];
-        const clientNames = entry.client ? parseExportNames(entry.client) : [];
-        if (entry.server && entry.client) {
-            const serverSet = new Set(serverNames);
-            const clientSet = new Set(clientNames);
-            const onlyServer = serverNames.filter((name) => !clientSet.has(name));
-            const onlyClient = clientNames.filter((name) => !serverSet.has(name));
-            if (onlyServer.length || onlyClient.length) {
-                logger.debug(`$rime/modules: ${subpath} — module.ts and module.server.ts export different names ` +
-                    `(server-only: ${onlyServer.join(', ') || 'none'}, client-only: ${onlyClient.join(', ') || 'none'})`);
-            }
-        }
-        const names = new Set([...serverNames, ...clientNames]);
-        for (const name of names) {
-            const existing = nameOwner.get(name);
-            if (existing && existing !== subpath) {
-                throw new Error(`$rime/modules: "${name}" exported by both ${existing} and ${subpath}`);
-            }
-            nameOwner.set(name, subpath);
-        }
-    }
-    return nameOwner;
-}
-/**
- * `dist/.rime-modules.json` (runtime, read by a consumer's Vite plugin) and
- * `dist/.rime-modules.d.ts` (types, referenced by a consumer's generated types).
- *
- * Both store paths *relative to `distDir`*, not absolute — confirmed in practice that an
- * absolute path here is a real bug, not just a style choice: it bakes in wherever `dist/`
- * happened to sit on the machine that ran `generate-manifest`, and a consumer's Vite plugin
- * (`vite/index.server.ts`'s `load()`, third-party qualified form) re-joins it onto the
- * *installed* package's own root (`findInstalledPackageRoot`) at read time. On a real install
- * that absolute path wouldn't even exist; on the same dev machine the package was authored on
- * it silently reads the author's own working-copy `dist/` instead of what's actually installed
- * in the consumer's `node_modules` - stale-looking field/behavior drift with no error raised.
- *
- * The `.d.ts` needs a *different* relative shape than the runtime manifest, verified directly
- * (a real `tsc` run — a plain filesystem path, absolute or relative, silently resolves to zero
- * exports inside a `declare module` block; only a bare package-qualified specifier, resolved
- * through the same `node_modules` mechanism a real import would use, actually works): every
- * `export *` target is `<pkgName>/dist/<subpath-relative-to-dist>`.
- */
-function writeManifest(distDir, pkgName, pairs) {
-    const manifest = {};
-    const dts = [];
-    const relativeToDist = (target) => path.relative(distDir, target).split(path.sep).join('/');
-    for (const [subpath, entry] of pairs) {
-        manifest[subpath] = {
-            client: entry.client ? relativeToDist(entry.client) : undefined,
-            server: entry.server ? relativeToDist(entry.server) : undefined
-        };
-        const target = entry.server || entry.client;
-        const bareSpecifier = `${pkgName}/dist/${relativeToDist(target)}`.replace(/\.ts$/, '.js');
-        dts.push(`declare module '$rime/modules/${pkgName}/${subpath}' {\n  export * from '${bareSpecifier}';\n}`);
-    }
-    fs.writeFileSync(path.join(distDir, '.rime-modules.json'), JSON.stringify(manifest));
-    fs.writeFileSync(path.join(distDir, '.rime-modules.d.ts'), dts.join('\n\n') + '\n');
-}
-/**
- * Walks every `.js`/`.d.ts` file under `dist/`, rewriting `import ... from '$rime/modules'`
- * into one `import ... from '$rime/modules/<pkg>/<subpath>'` per split its specifiers actually
- * draw from — a single barrel import can (and often will) pull names from several different
- * splits at once, each becoming its own import statement.
- *
- * Every rewritten `.d.ts` file also gets a `/// <reference path="...">` to `.rime-modules.d.ts`
- * prepended, making it self-contained — verified directly (a real `tsc` run): without it, a
- * consumer never discovers the ambient `declare module '$rime/modules/<pkg>/...'` declarations
- * at all, *even from a file inside this same package*, since nothing imports `.rime-modules.d.ts`
- * and it's outside any project's own `include`. Doing it here means the *consumer* never needs
- * to know this package exists just to get its types working — no eager, app-side aggregation
- * of every installed rime-dependent package required.
- */
-function rewriteBarrelImports(distDir, pkgName, nameOwner) {
-    const walk = (dir) => {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(fullPath);
-                continue;
-            }
-            if (!entry.name.endsWith('.js') && !entry.name.endsWith('.d.ts'))
-                continue;
-            const content = fs.readFileSync(fullPath, 'utf-8');
-            if (!content.includes('$rime/modules'))
-                continue;
-            const ast = babelParse(content, 'ts', { sourceType: 'module', attachComment: true });
-            let changed = false;
-            const newBody = [];
-            for (const node of ast.body) {
-                // `import { x } from '$rime/modules'` (runtime .js) and the equivalent re-export
-                // `export { x } from '$rime/modules'` (declaration .d.ts, what tsc/svelte-package
-                // actually emits — a real end-to-end run caught this, not something guessable) both
-                // need the same treatment.
-                if (t.isImportDeclaration(node) && node.source.value === '$rime/modules') {
-                    changed = true;
-                    newBody.push(...splitBarrelImport(node, fullPath, pkgName, nameOwner));
-                    continue;
-                }
-                if (t.isExportNamedDeclaration(node) && node.source?.value === '$rime/modules') {
-                    changed = true;
-                    newBody.push(...splitBarrelReExport(node, fullPath, pkgName, nameOwner));
-                    continue;
-                }
-                if (t.isExportAllDeclaration(node) && node.source.value === '$rime/modules') {
-                    throw new Error(`$rime/modules: ${fullPath} does 'export * from $rime/modules' — ambiguous, can't tell which split each re-exported name belongs to. Import/re-export specific names instead.`);
-                }
-                newBody.push(node);
-            }
-            if (changed) {
-                ast.body = newBody;
-                const { code } = generate(ast, { compact: false, comments: true });
-                fs.writeFileSync(fullPath, entry.name.endsWith('.d.ts') ? withManifestReference(code, fullPath, distDir) : code);
-            }
-        }
-    };
-    walk(distDir);
-}
-function withManifestReference(code, fullPath, distDir) {
-    const relative = path
-        .relative(path.dirname(fullPath), path.join(distDir, '.rime-modules.d.ts'))
-        .split(path.sep)
-        .join('/');
-    const referencePath = relative.startsWith('.') ? relative : `./${relative}`;
-    return `/// <reference path="${referencePath}" />\n${code}`;
-}
-/** `import { x } from '$rime/modules'` (runtime .js) — groups specifiers by which split each
- *  name actually belongs to (via `nameOwner`, built by `buildModuleIndex`), one import
- *  statement per split. */
-function splitBarrelImport(node, fullPath, pkgName, nameOwner) {
-    const bySubpath = new Map();
-    for (const spec of node.specifiers) {
-        if (!t.isImportSpecifier(spec)) {
-            throw new Error(`$rime/modules: ${fullPath} imports the barrel with a default/namespace specifier — only named imports are supported`);
-        }
-        const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-        const subpath = nameOwner.get(importedName);
-        if (!subpath) {
-            throw new Error(`$rime/modules: '${importedName}' imported in ${fullPath} but not exported by any split`);
-        }
-        if (!bySubpath.has(subpath))
-            bySubpath.set(subpath, []);
-        bySubpath.get(subpath).push(spec);
-    }
-    return Array.from(bySubpath.entries()).map(([subpath, specs]) => t.importDeclaration(specs, t.stringLiteral(`$rime/modules/${pkgName}/${subpath}`)));
-}
-/** `export { x } from '$rime/modules'` — what `tsc`/`svelte-package` actually emits in `.d.ts`
- *  output (a real end-to-end run caught this; `import`+`export` pairs aren't the only shape).
- *  Same grouping as `splitBarrelImport`, just keyed off `.local` (the name as it exists in the
- *  source module) instead of `.imported` — `ExportSpecifier` doesn't have that field. */
-function splitBarrelReExport(node, fullPath, pkgName, nameOwner) {
-    const bySubpath = new Map();
-    for (const spec of node.specifiers) {
-        if (!t.isExportSpecifier(spec)) {
-            throw new Error(`$rime/modules: ${fullPath} re-exports the barrel with a default/namespace specifier — only named exports are supported`);
-        }
-        const localName = spec.local.name;
-        const subpath = nameOwner.get(localName);
-        if (!subpath) {
-            throw new Error(`$rime/modules: '${localName}' re-exported in ${fullPath} but not exported by any split`);
-        }
-        if (!bySubpath.has(subpath))
-            bySubpath.set(subpath, []);
-        bySubpath.get(subpath).push(spec);
-    }
-    return Array.from(bySubpath.entries()).map(([subpath, specs]) => t.exportNamedDeclaration(null, specs, t.stringLiteral(`$rime/modules/${pkgName}/${subpath}`)));
-}

package/dist/core/dev/cli/init/index.server.js

@@ -1,241 +0,0 @@
-import { logger } from '../../../logger/index.server.js';
-import { randomId } from '../../../../util/random.js';
-import { isValidSlug, slugify } from '../../../../util/string.js';
-import { generate as generateCode } from '@babel/generator';
-import * as t from '@babel/types';
-import { babelParse, getLang } from 'ast-kit';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { cp, mkdir } from 'fs/promises';
-import fs from 'node:fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { CONFIG_DIR, OUTPUT_DIR, PANEL_ROUTE } from '../../constants.js';
-import { generate } from '../generate/index.server.js';
-import { installDependencies } from '../util/package-manager.server.js';
-import { getPackageInfoByKey } from '../util/package.server.js';
-import { prompt } from '../util/prompt.server.js';
-import * as templates from './templates.js';
-const PACKAGE = 'rimecms';
-const root = process.cwd();
-export const init = async ({ force, name: incomingName, skipInstall }) => {
-    const packageName = getPackageInfoByKey('name');
-    function setEnv() {
-        const envPath = path.resolve(root, '.env');
-        // Define variables with their update behavior
-        const envUpdates = {
-            BETTER_AUTH_SECRET: randomId(32),
-            PUBLIC_RIME_URL: 'http://localhost:5173',
-            RIME_CONFIG_DIR: CONFIG_DIR,
-            RIME_PANEL_ROUTE: PANEL_ROUTE,
-            '# RIME_SMTP_USER': 'user@mail.com',
-            '# RIME_SMTP_PASSWORD': 'supersecret',
-            '# RIME_SMTP_PORT': '465',
-            '# RIME_SMTP_HOST': 'smtphost.com',
-            RIME_LOG_LEVEL: 'TRACE',
-            RIME_LOG_TO_FILE: 'true',
-            RIME_LOG_TO_FILE_MAX_DAYS: '1'
-        };
-        if (existsSync(envPath)) {
-            logger.info('[✓] .env file found');
-            let envContent = readFileSync(envPath, 'utf-8');
-            Object.entries(envUpdates).forEach(([key, value]) => {
-                const exists = envContent.match(new RegExp(`^${key}=`, 'm'));
-                if (!exists) {
-                    // Add new value if doesn't exist
-                    envContent += `\n${key}=${value}`;
-                    logger.info(`- ${key} added`);
-                }
-            });
-            writeFileSync(envPath, envContent);
-            logger.info('[✓] .env file populated');
-        }
-        else {
-            writeFileSync(envPath, templates.env());
-            logger.info('[✓] .env file created');
-        }
-    }
-    function setConfig(name) {
-        const configDirPath = path.resolve(root, CONFIG_DIR);
-        const configPath = path.join(configDirPath, 'rime.config.server.ts');
-        if (!existsSync(configPath)) {
-            if (!existsSync(configDirPath)) {
-                mkdirSync(configDirPath);
-            }
-            writeFileSync(configPath, templates.defaultConfig(name.toString()));
-            logger.info(`[✓] Config created at ${configDirPath}/rime.config.server.ts`);
-        }
-        else {
-            logger.info('[✓] Config already exists (skip)');
-        }
-    }
-    function setDatabase() {
-        const dbPath = path.join(root, 'db');
-        if (!existsSync(dbPath)) {
-            mkdirSync(dbPath);
-            logger.info('[✓] Database folder created');
-        }
-        else {
-            logger.info('[✓] Database folder already exists (skip)');
-        }
-    }
-    function addToGitignore() {
-        const gitignorePath = path.join(root, '.gitignore');
-        if (!existsSync(gitignorePath)) {
-            logger.warn('.gitignore not found (skip)');
-            return;
-        }
-        let gitignoreContent = readFileSync(gitignorePath, 'utf-8');
-        // OUTPUT_DIR is derived from RIME_CONFIG_DIR, so its first character isn't always '+' —
-        // escape every regex metacharacter generically instead of hand-picking one to backslash.
-        const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const updates = [
-            '.cache',
-            '/logs',
-            '/db',
-            OUTPUT_DIR,
-            'src/app.generated.d.ts',
-            'src/rime.generated.d.ts'
-        ];
-        if (!gitignoreContent.includes('# rime'))
-            gitignoreContent += '\n# rime';
-        for (const line of updates) {
-            const exists = gitignoreContent.match(new RegExp(`^${escapeRegExp(line)}`, 'm'));
-            if (!exists) {
-                // Add new value if doesn't exist
-                gitignoreContent += `\n${line}`;
-            }
-        }
-        writeFileSync(gitignorePath, gitignoreContent);
-        logger.info('[✓] .gitignore populated');
-    }
-    function setDrizzle(name) {
-        const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
-        if (!existsSync(drizzleConfigPath)) {
-            writeFileSync(drizzleConfigPath, templates.drizzleConfig(name.toString()));
-            logger.info('[✓] Drizzle config added');
-            return;
-        }
-        logger.info(templates.regenerateDrizzleConfig(root)
-            ? '[✓] Drizzle config schema path updated'
-            : '[✓] Drizzle config already exists (skip)');
-    }
-    function configureVite() {
-        const configPath = path.resolve(root, 'vite.config.ts');
-        if (!fs.existsSync(configPath)) {
-            throw new Error("Can't find vite configuration file");
-        }
-        let content = fs.readFileSync(configPath, 'utf-8');
-        content = content.replace("from '@sveltejs/adapter-auto'", "from '@sveltejs/adapter-node'");
-        const program = babelParse(content, getLang(configPath));
-        const programBody = program.body;
-        const configObject = findSvelteConfigObject(programBody);
-        if (!configObject) {
-            throw new Error("Couldn't find the Vite config object (defineConfig({...}) or export default {...})");
-        }
-        const pluginsProp = configObject.properties.find((p) => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === 'plugins');
-        if (!pluginsProp || !t.isArrayExpression(pluginsProp.value)) {
-            throw new Error("Couldn't find a `plugins: [...]` array in the Vite config object");
-        }
-        const pluginsArray = pluginsProp.value;
-        const alreadyPresent = pluginsArray.elements.some((el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === 'rime');
-        if (alreadyPresent) {
-            logger.info('[✓] Vite plugin already present (skip)');
-            return;
-        }
-        const hasImport = programBody.some((node) => t.isImportDeclaration(node) &&
-            node.source.value === `${PACKAGE}/vite` &&
-            node.specifiers.some((s) => t.isImportSpecifier(s) && t.isIdentifier(s.imported) && s.imported.name === 'rime'));
-        if (!hasImport) {
-            const importDecl = t.importDeclaration([t.importSpecifier(t.identifier('rime'), t.identifier('rime'))], t.stringLiteral(`${PACKAGE}/vite`));
-            programBody.unshift(importDecl);
-        }
-        const rimeCall = t.callExpression(t.identifier('rime'), []);
-        const sveltekitIndex = pluginsArray.elements.findIndex((el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === 'sveltekit');
-        if (sveltekitIndex !== -1) {
-            pluginsArray.elements.splice(sveltekitIndex + 1, 0, rimeCall);
-        }
-        else {
-            pluginsArray.elements.push(rimeCall);
-        }
-        const file = t.file(program);
-        const { code } = generateCode(file, {}, content);
-        fs.writeFileSync(configPath, code);
-        logger.info('[✓] Vite plugin added');
-    }
-    function findSvelteConfigObject(body) {
-        for (const node of body) {
-            if (t.isExpressionStatement(node) &&
-                t.isCallExpression(node.expression) &&
-                t.isIdentifier(node.expression.callee) &&
-                node.expression.callee.name === 'defineConfig') {
-                const arg = node.expression.arguments[0];
-                if (t.isObjectExpression(arg))
-                    return arg;
-            }
-            if (t.isExportDefaultDeclaration(node)) {
-                const decl = node.declaration;
-                if (t.isCallExpression(decl) &&
-                    t.isIdentifier(decl.callee) &&
-                    decl.callee.name === 'defineConfig') {
-                    const arg = decl.arguments[0];
-                    if (t.isObjectExpression(arg))
-                        return arg;
-                }
-                if (t.isObjectExpression(decl)) {
-                    return decl;
-                }
-            }
-        }
-        return null;
-    }
-    async function copyAssets() {
-        try {
-            const currentDir = path.dirname(fileURLToPath(import.meta.url));
-            await mkdir(path.resolve(process.cwd(), 'static/assets/panel/fonts'), { recursive: true });
-            await cp(path.join(currentDir, '../../../../panel/fonts'), path.resolve(process.cwd(), 'static/assets/panel/fonts'), {
-                recursive: true
-            });
-            logger.info('[✓] Copied assets');
-        }
-        catch (err) {
-            console.error('Error copying fonts:', err);
-        }
-    }
-    if (force || incomingName) {
-        const name = incomingName || packageName;
-        setEnv();
-        addToGitignore();
-        setConfig(name);
-        setDatabase();
-        setDrizzle(name);
-        configureVite();
-        await copyAssets();
-        !skipInstall && installDependencies();
-        await generate({ force: true });
-    }
-    else {
-        let name = '';
-        const defaultName = slugify(packageName);
-        let tries = 0;
-        while (!isValidSlug(name)) {
-            name = await prompt(tries > 0
-                ? 'Error: should contains only letters, numbers, hyphens, underscores\nWhat is your project name (will be used as database name) ?'
-                : 'What is your project name (will be used as database name) ?', defaultName || 'app');
-            tries++;
-        }
-        if (!name) {
-            logger.error('Operation cancelled');
-            process.exit(0);
-        }
-        setEnv();
-        addToGitignore();
-        setConfig(name);
-        setDatabase();
-        setDrizzle(name);
-        configureVite();
-        await copyAssets();
-        !skipInstall && installDependencies();
-        await generate({ force: true });
-        logger.info('[✓] done');
-    }
-};