@starodubenko/fsd-gen 0.1.0

package/dist/lib/preset/actionExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionExecution.d.ts","sourceRoot":"","sources":["../../../src/lib/preset/actionExecution.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAK5G;;GAEG;AACH,wBAAgB,sBAAsB,CAClC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAOrB;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CACxC,MAAM,EAAE,qBAAqB,EAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC9B,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,IAAI,CAAC,CAmBf;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,MAAM,EAAE,GAAG,EAAE,iEAAiE;AAC9E,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC9B,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,IAAI,CAAC,CAmBf;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACrC,MAAM,EAAE,GAAG,EACX,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC9B,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,IAAI,CAAC,CAmBf;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAClC,YAAY,EAAE,MAAM,EACpB,kBAAkB,CAAC,EAAE,MAAM,GAC5B,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC9B,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAChC,OAAO,EAAE,YAAY,EAAE,EACvB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,IAAI,CAAC,CAqBf"}

package/dist/lib/preset/actionExecution.js

@@ -0,0 +1,138 @@
+/**
+ * Action execution engine for presets.
+ *
+ * Responsible for executing the individual actions defined in a preset (e.g., creating files,
+ * updating barrels, generating components). Handles variable substitution and logic execution.
+ */
+import { join, resolve, dirname, basename } from 'path';
+import { writeFile, mkdir, readFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { updateBarrel } from '../barrels/updateBarrels.js';
+import { ACTION_TYPES, FILE_EXTENSIONS } from '../constants.js';
+import { generateComponent, generateHook, generateStyles } from '../generators/generate.js';
+import { resolveFsdPaths } from '../naming/resolvePaths.js';
+import { processTemplate } from '../templates/templateLoader.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Prepare variables for an action by merging global and action-specific variables
+ */
+export function prepareActionVariables(action, name, globalVars) {
+    return {
+        name,
+        componentName: name,
+        ...globalVars,
+        ...action.variables
+    };
+}
+/**
+ * Execute a component action (generate a component)
+ */
+export async function executeComponentAction(action, variables, config) {
+    const componentName = processTemplate(action.name || action.slice, variables);
+    const sliceName = processTemplate(action.slice, variables);
+    const paths = resolveFsdPaths(config.rootDir, action.layer, sliceName, componentName);
+    const context = {
+        ...variables,
+        componentName,
+        sliceName,
+        layer: action.layer,
+    };
+    await generateComponent(paths, context, action.template, config.templatesDir);
+}
+/**
+ * Execute a hook action
+ */
+export async function executeHookAction(action, // Using any for now to avoid complexity with union types in loop
+variables, config) {
+    const componentName = processTemplate(action.name || action.slice, variables);
+    const sliceName = processTemplate(action.slice, variables);
+    const paths = resolveFsdPaths(config.rootDir, action.layer, sliceName, componentName);
+    const context = {
+        ...variables,
+        componentName,
+        sliceName,
+        layer: action.layer,
+    };
+    await generateHook(paths, context, action.template, config.templatesDir);
+}
+/**
+ * Execute a styles action
+ */
+export async function executeStylesAction(action, variables, config) {
+    const componentName = processTemplate(action.name || action.slice, variables);
+    const sliceName = processTemplate(action.slice, variables);
+    const paths = resolveFsdPaths(config.rootDir, action.layer, sliceName, componentName);
+    const context = {
+        ...variables,
+        componentName,
+        sliceName,
+        layer: action.layer,
+    };
+    await generateStyles(paths, context, action.template, config.templatesDir);
+}
+/**
+ * Load a file template from the templates directory
+ */
+export async function loadFileTemplate(templatePath, customTemplatesDir) {
+    const internalTemplatesDir = join(__dirname, '../../../templates');
+    const pathsToCheck = [];
+    if (customTemplatesDir) {
+        pathsToCheck.push(join(resolve(process.cwd(), customTemplatesDir), templatePath));
+    }
+    pathsToCheck.push(join(internalTemplatesDir, templatePath));
+    for (const p of pathsToCheck) {
+        try {
+            const content = await readFile(p, 'utf-8');
+            console.log(`Loaded file template from: ${p}`);
+            return content;
+        }
+        catch {
+            // Try next path
+        }
+    }
+    throw new Error(`Could not find file template: ${templatePath}`);
+}
+/**
+ * Execute a file action (create a file from template)
+ */
+export async function executeFileAction(action, variables, config) {
+    const targetPath = join(process.cwd(), config.rootDir, processTemplate(action.path, variables));
+    await mkdir(dirname(targetPath), { recursive: true });
+    if (action.template) {
+        const content = await loadFileTemplate(action.template, config.templatesDir);
+        const processed = processTemplate(content, variables);
+        await writeFile(targetPath, processed);
+        console.log(`Created ${targetPath}`);
+        // Update barrel for the file (only for TypeScript files)
+        if (targetPath.endsWith(FILE_EXTENSIONS.TYPESCRIPT) || targetPath.endsWith(FILE_EXTENSIONS.TSX)) {
+            const dir = dirname(targetPath);
+            const fileName = basename(targetPath, FILE_EXTENSIONS.TYPESCRIPT); // Remove .ts for export
+            updateBarrel(dir, fileName, fileName);
+        }
+    }
+}
+/**
+ * Execute all preset actions
+ * Orchestrates executing component and file actions
+ */
+export async function executeActions(actions, name, globalVars, config) {
+    for (const action of actions) {
+        const variables = prepareActionVariables(action, name, globalVars);
+        switch (action.type) {
+            case ACTION_TYPES.COMPONENT:
+                await executeComponentAction(action, variables, config);
+                break;
+            case ACTION_TYPES.FILE:
+                await executeFileAction(action, variables, config);
+                break;
+            case ACTION_TYPES.HOOK:
+                await executeHookAction(action, variables, config);
+                break;
+            case ACTION_TYPES.STYLES:
+                await executeStylesAction(action, variables, config);
+                break;
+        }
+    }
+    console.log('Preset generation complete (declarative).');
+}

package/dist/lib/preset/presetDiscovery.d.ts

@@ -0,0 +1,40 @@
+import type { Dirent } from 'fs';
+import { PresetAction, PresetComponentAction, PresetFileAction, ConventionConfig } from '../../config/types.js';
+/**
+ * Scan a layer directory for entries
+ */
+export declare function scanLayerDirectory(presetDir: string, layer: string): Promise<Dirent[]>;
+/**
+ * Create a file action from a .ts file entry
+ */
+export declare function createFileAction(entry: Dirent, layer: string, entityName: string, presetName: string): PresetFileAction;
+/**
+ * Create component action for entity UI
+ */
+export declare function createEntityUiAction(entityName: string, presetName: string): PresetComponentAction;
+/**
+ * Create component actions for entity API hooks
+ */
+export declare function createEntityApiActions(apiDir: string, entityName: string, presetName: string): Promise<PresetAction[]>;
+/**
+ * Create component actions for feature buttons
+ */
+export declare function createFeatureButtonActions(buttonsDir: string, entityName: string, presetName: string, conventions: ConventionConfig): Promise<PresetAction[]>;
+/**
+ * Create component action for widget table
+ */
+export declare function createWidgetTableAction(entityName: string, presetName: string, conventions: ConventionConfig): PresetComponentAction;
+/**
+ * Create component action for page
+ */
+export declare function createPageAction(entityName: string, presetName: string, conventions: ConventionConfig): PresetComponentAction;
+/**
+ * Create component action for shared
+ */
+export declare function createSharedAction(entryName: string, entityName: string, presetName: string): PresetComponentAction;
+/**
+ * Auto-discover templates in a preset directory based on conventions
+ * Orchestrates scanning all layers and creating appropriate actions
+ */
+export declare function discoverTemplates(presetDir: string, presetName: string, entityName: string, conventions?: ConventionConfig): Promise<PresetAction[]>;
+//# sourceMappingURL=presetDiscovery.d.ts.map

package/dist/lib/preset/presetDiscovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presetDiscovery.d.ts","sourceRoot":"","sources":["../../../src/lib/preset/presetDiscovery.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAYhH;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAW5F;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC5B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACnB,gBAAgB,CASlB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACnB,qBAAqB,CAQvB;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACnB,OAAO,CAAC,YAAY,EAAE,CAAC,CAuBzB;AAED;;GAEG;AACH,wBAAsB,0BAA0B,CAC5C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,gBAAgB,GAC9B,OAAO,CAAC,YAAY,EAAE,CAAC,CAoBzB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACnC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,gBAAgB,GAC9B,qBAAqB,CAUvB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC5B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,gBAAgB,GAC9B,qBAAqB,CAUvB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACnB,qBAAqB,CAUvB;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACnC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,WAAW,GAAE,gBAAqB,GACnC,OAAO,CAAC,YAAY,EAAE,CAAC,CAqDzB"}

package/dist/lib/preset/presetDiscovery.js

@@ -0,0 +1,189 @@
+/**
+ * Preset discovery mechanism.
+ *
+ * Scans the preset directory structure to automatically discover and register template actions.
+ * Converts the file system structure of a preset into a list of executable generator actions.
+ */
+/**
+ * Preset discovery mechanism.
+ *
+ * Scans the preset directory structure to automatically discover and register template actions.
+ * Converts the file system structure of a preset into a list of executable generator actions.
+ */
+import { readdir, stat } from 'fs/promises';
+import { join } from 'path';
+import { LAYER_PLURALS, FSD_LAYERS, FSD_SEGMENTS, FILE_EXTENSIONS, PRESET_DIRS, API_HOOK_PREFIXES, API_OPERATIONS, ACTION_TYPES } from '../constants.js';
+/**
+ * Scan a layer directory for entries
+ */
+export async function scanLayerDirectory(presetDir, layer) {
+    const layerDir = join(presetDir, layer);
+    try {
+        const layerStat = await stat(layerDir);
+        if (!layerStat.isDirectory())
+            return [];
+        return await readdir(layerDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Create a file action from a .ts file entry
+ */
+export function createFileAction(entry, layer, entityName, presetName) {
+    const baseName = entry.name.replace(FILE_EXTENSIONS.TYPESCRIPT, '');
+    const layerPlural = LAYER_PLURALS[layer] || 'pages';
+    return {
+        type: ACTION_TYPES.FILE,
+        path: `${layerPlural}/${entityName}/${FSD_SEGMENTS.MODEL}/${baseName}${FILE_EXTENSIONS.TYPESCRIPT}`,
+        template: `${PRESET_DIRS.ROOT}/${presetName}/${layer}/${entry.name}`
+    };
+}
+/**
+ * Create component action for entity UI
+ */
+export function createEntityUiAction(entityName, presetName) {
+    return {
+        type: ACTION_TYPES.COMPONENT,
+        layer: FSD_LAYERS.ENTITY,
+        slice: entityName,
+        name: entityName,
+        template: `${PRESET_DIRS.ROOT}/${presetName}/${FSD_LAYERS.ENTITY}/${FSD_SEGMENTS.UI}`
+    };
+}
+/**
+ * Create component actions for entity API hooks
+ */
+export async function createEntityApiActions(apiDir, entityName, presetName) {
+    const actions = [];
+    const apiEntries = await readdir(apiDir, { withFileTypes: true });
+    for (const apiEntry of apiEntries) {
+        if (apiEntry.isDirectory()) {
+            const hookName = apiEntry.name;
+            const hookPrefix = API_HOOK_PREFIXES[hookName];
+            const name = hookPrefix
+                ? `${hookPrefix}${entityName}${hookName === API_OPERATIONS.GET ? 's' : ''}`
+                : `use${hookName.charAt(0).toUpperCase() + hookName.slice(1)}${entityName}`;
+            actions.push({
+                type: ACTION_TYPES.HOOK,
+                layer: FSD_LAYERS.ENTITY,
+                slice: entityName,
+                name,
+                template: `${PRESET_DIRS.ROOT}/${presetName}/${FSD_LAYERS.ENTITY}/${FSD_SEGMENTS.API}/${apiEntry.name}`
+            });
+        }
+    }
+    return actions;
+}
+/**
+ * Create component actions for feature buttons
+ */
+export async function createFeatureButtonActions(buttonsDir, entityName, presetName, conventions) {
+    const actions = [];
+    const featurePrefix = conventions.featureSlicePrefix ?? 'Manage';
+    const buttonEntries = await readdir(buttonsDir, { withFileTypes: true });
+    for (const buttonEntry of buttonEntries) {
+        if (buttonEntry.isDirectory()) {
+            const buttonType = buttonEntry.name; // create, edit, delete
+            const capitalizedType = buttonType.charAt(0).toUpperCase() + buttonType.slice(1);
+            actions.push({
+                type: ACTION_TYPES.COMPONENT,
+                layer: FSD_LAYERS.FEATURE,
+                slice: `${featurePrefix}${entityName}`,
+                name: `${capitalizedType}${entityName}Button`,
+                template: `${PRESET_DIRS.ROOT}/${presetName}/${FSD_LAYERS.FEATURE}/${PRESET_DIRS.BUTTONS}/${buttonEntry.name}`
+            });
+        }
+    }
+    return actions;
+}
+/**
+ * Create component action for widget table
+ */
+export function createWidgetTableAction(entityName, presetName, conventions) {
+    const widgetSuffix = conventions.widgetSliceSuffix ?? 'Table';
+    return {
+        type: ACTION_TYPES.COMPONENT,
+        layer: FSD_LAYERS.WIDGET,
+        slice: `${entityName}${widgetSuffix}`,
+        name: `${entityName}${widgetSuffix}`,
+        template: `${PRESET_DIRS.ROOT}/${presetName}/${FSD_LAYERS.WIDGET}/${PRESET_DIRS.TABLE}`
+    };
+}
+/**
+ * Create component action for page
+ */
+export function createPageAction(entityName, presetName, conventions) {
+    const pageSuffix = conventions.pageSliceSuffix ?? 'Page';
+    return {
+        type: ACTION_TYPES.COMPONENT,
+        layer: FSD_LAYERS.PAGE,
+        slice: `${entityName}${pageSuffix}`,
+        name: `${entityName}${pageSuffix}`,
+        template: `${PRESET_DIRS.ROOT}/${presetName}/${FSD_LAYERS.PAGE}/${FSD_LAYERS.PAGE}`
+    };
+}
+/**
+ * Create component action for shared
+ */
+export function createSharedAction(entryName, entityName, presetName) {
+    // Shared components often don't follow entity naming directly,
+    // but in discovery mode we treat existing dirs as components.
+    return {
+        type: ACTION_TYPES.COMPONENT,
+        layer: FSD_LAYERS.SHARED,
+        slice: entryName === FSD_LAYERS.SHARED ? entityName : entryName,
+        name: entryName === FSD_LAYERS.SHARED ? entityName : entryName,
+        template: `${PRESET_DIRS.ROOT}/${presetName}/${FSD_LAYERS.SHARED}/${entryName}`
+    };
+}
+/**
+ * Auto-discover templates in a preset directory based on conventions
+ * Orchestrates scanning all layers and creating appropriate actions
+ */
+export async function discoverTemplates(presetDir, presetName, entityName, conventions = {}) {
+    const actions = [];
+    const layers = ['entity', 'feature', 'widget', 'page', 'shared'];
+    for (const layer of layers) {
+        const entries = await scanLayerDirectory(presetDir, layer);
+        for (const entry of entries) {
+            const fullPath = join(presetDir, layer, entry.name);
+            // Check for .ts files (file actions)
+            if (entry.isFile() && entry.name.endsWith(FILE_EXTENSIONS.TYPESCRIPT)) {
+                actions.push(createFileAction(entry, layer, entityName, presetName));
+            }
+            // Check for directories (component actions)
+            if (entry.isDirectory()) {
+                // Entity layer
+                if (layer === FSD_LAYERS.ENTITY) {
+                    if (entry.name === FSD_SEGMENTS.UI) {
+                        actions.push(createEntityUiAction(entityName, presetName));
+                    }
+                    else if (entry.name === FSD_SEGMENTS.API) {
+                        const apiActions = await createEntityApiActions(fullPath, entityName, presetName);
+                        actions.push(...apiActions);
+                    }
+                }
+                // Feature layer
+                else if (layer === FSD_LAYERS.FEATURE && entry.name === PRESET_DIRS.BUTTONS) {
+                    const buttonActions = await createFeatureButtonActions(fullPath, entityName, presetName, conventions);
+                    actions.push(...buttonActions);
+                }
+                // Widget layer
+                else if (layer === FSD_LAYERS.WIDGET && entry.name === PRESET_DIRS.TABLE) {
+                    actions.push(createWidgetTableAction(entityName, presetName, conventions));
+                }
+                // Page layer
+                else if (layer === FSD_LAYERS.PAGE && entry.name === FSD_LAYERS.PAGE) {
+                    actions.push(createPageAction(entityName, presetName, conventions));
+                }
+                // Shared layer
+                else if (layer === FSD_LAYERS.SHARED) {
+                    actions.push(createSharedAction(entry.name, entityName, presetName));
+                }
+            }
+        }
+    }
+    return actions;
+}

package/dist/lib/preset/presetLoading.d.ts

@@ -0,0 +1,22 @@
+import { PresetConfig, PresetConfigArgs, PresetConfigFn, FsdGenConfig } from '../../config/types.js';
+/**
+ * Load preset configuration from preset.ts file
+ * @returns The preset config or null if not found
+ */
+export declare function loadPresetTs(presetDir: string): Promise<PresetConfig | PresetConfigFn | null>;
+/**
+ * Load preset configuration from preset.json file
+ * @returns The preset config or null if not found
+ */
+export declare function loadPresetJson(presetDir: string): Promise<PresetConfig | null>;
+/**
+ * Evaluate preset config if it's a function
+ */
+export declare function evaluatePresetConfig(config: PresetConfig | PresetConfigFn, args: PresetConfigArgs): PresetConfig;
+/**
+ * Load preset configuration from a preset directory
+ * Tries preset.ts first, then preset.json
+ * Orchestrates the entire preset config loading process
+ */
+export declare function loadPresetConfig(presetDir: string, name: string, config: FsdGenConfig): Promise<PresetConfig | null>;
+//# sourceMappingURL=presetLoading.d.ts.map

package/dist/lib/preset/presetLoading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presetLoading.d.ts","sourceRoot":"","sources":["../../../src/lib/preset/presetLoading.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErG;;;GAGG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,cAAc,GAAG,IAAI,CAAC,CAanG;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAUpF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,YAAY,GAAG,cAAc,EACrC,IAAI,EAAE,gBAAgB,GACvB,YAAY,CAKd;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAClC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAgB9B"}

package/dist/lib/preset/presetLoading.js

@@ -0,0 +1,69 @@
+/**
+ * Preset loading logic.
+ *
+ * Responsible for loading preset configurations from either TypeScript files (preset.ts)
+ * or JSON files (preset.json). Handles module resolution and parsing.
+ */
+import { join } from 'path';
+import { readFile, stat } from 'fs/promises';
+import { createJiti } from 'jiti';
+/**
+ * Load preset configuration from preset.ts file
+ * @returns The preset config or null if not found
+ */
+export async function loadPresetTs(presetDir) {
+    const presetTsPath = join(presetDir, 'preset.ts');
+    try {
+        await stat(presetTsPath);
+        console.log(`Loading preset configuration from ${presetTsPath}...`);
+        const jiti = createJiti(import.meta.url);
+        const imported = await jiti.import(presetTsPath, { default: true });
+        return imported.default || imported;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load preset configuration from preset.json file
+ * @returns The preset config or null if not found
+ */
+export async function loadPresetJson(presetDir) {
+    const presetJsonPath = join(presetDir, 'preset.json');
+    try {
+        const content = await readFile(presetJsonPath, 'utf-8');
+        console.log(`Found preset.json at ${presetJsonPath}...`);
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Evaluate preset config if it's a function
+ */
+export function evaluatePresetConfig(config, args) {
+    if (typeof config === 'function') {
+        return config(args);
+    }
+    return config;
+}
+/**
+ * Load preset configuration from a preset directory
+ * Tries preset.ts first, then preset.json
+ * Orchestrates the entire preset config loading process
+ */
+export async function loadPresetConfig(presetDir, name, config) {
+    // Try preset.ts first
+    let presetConfig = await loadPresetTs(presetDir);
+    // Fall back to preset.json
+    if (!presetConfig) {
+        presetConfig = await loadPresetJson(presetDir);
+    }
+    if (!presetConfig) {
+        return null;
+    }
+    // Evaluate if function
+    const args = { name, config };
+    return evaluatePresetConfig(presetConfig, args);
+}

package/dist/lib/routing/injectRoute.d.ts

@@ -0,0 +1,17 @@
+export interface RouteInjectionOptions {
+    /** Root directory where App.tsx is located */
+    rootDir: string;
+    /** Route path (e.g., '/test') */
+    path: string;
+    /** Import path for the page component (e.g., '@pages/TestPage') */
+    importPath: string;
+    /** Component name (e.g., 'TestPage') */
+    componentName: string;
+    /** Target file for route injection (e.g., 'App.tsx') @default "App.tsx" */
+    appFile?: string;
+}
+/**
+ * Inject a route into App.tsx
+ */
+export declare function injectRoute(options: RouteInjectionOptions): Promise<void>;
+//# sourceMappingURL=injectRoute.d.ts.map

package/dist/lib/routing/injectRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectRoute.d.ts","sourceRoot":"","sources":["../../../src/lib/routing/injectRoute.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,qBAAqB;IAClC,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAKD;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+D/E"}

package/dist/lib/routing/injectRoute.js

@@ -0,0 +1,66 @@
+/**
+ * Route injection logic.
+ *
+ * Handles the automatic injection of routes into the main application entry point (e.g. App.tsx)
+ * when a page is generated. Parses the AST to find the correct insertion point.
+ */
+import { join } from 'path';
+import { ROUTING } from '../constants.js';
+import { readFile, writeFile } from 'fs/promises';
+/**
+ * Inject a route into App.tsx
+ */
+export async function injectRoute(options) {
+    const { rootDir, path, importPath, componentName, appFile = ROUTING.APP_FILE } = options;
+    const appFilePath = join(rootDir, appFile);
+    try {
+        // Read App.tsx
+        let content = await readFile(appFilePath, 'utf-8');
+        // Check if route injection point exists
+        if (!content.includes(ROUTING.MARKER)) {
+            console.warn(`⚠️  Warning: ${ROUTING.MARKER} comment not found in ${ROUTING.APP_FILE}`);
+            console.warn('   Route was not injected automatically.');
+            return;
+        }
+        // Generate import statement
+        const importStatement = `import { ${componentName} } from '${importPath}';\n`;
+        // Check if import already exists
+        if (content.includes(importStatement.trim())) {
+            console.log(`ℹ️  Import for ${componentName} already exists, skipping...`);
+        }
+        else {
+            // Find where to insert import (after last import statement)
+            const lines = content.split('\n');
+            let lastImportIndex = -1;
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].match(/^import\s/)) {
+                    lastImportIndex = i;
+                }
+            }
+            if (lastImportIndex >= 0) {
+                lines.splice(lastImportIndex + 1, 0, importStatement.trimEnd());
+                content = lines.join('\n');
+            }
+        }
+        // Generate route element
+        const routeElement = `            <Route path="${path}" element={<${componentName} />} />`;
+        // Check if route already exists
+        if (content.includes(`path="${path}"`)) {
+            console.log(`ℹ️  Route for path "${path}" already exists, skipping...`);
+            return;
+        }
+        // Insert route at injection point
+        content = content.replace(ROUTING.MARKER, `${routeElement}\n            ${ROUTING.MARKER}`);
+        // Write back to file
+        await writeFile(appFilePath, content, 'utf-8');
+        console.log(`✅ Injected route "${path}" -> ${componentName}`);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            console.warn('⚠️  Warning: App.tsx not found, route injection skipped');
+        }
+        else {
+            throw error;
+        }
+    }
+}

package/dist/lib/templates/templateLoader.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Resolve the list of directories to search for templates
+ * Custom directory is checked first, then internal templates
+ */
+export declare function resolveTemplateDirs(customTemplatesDir?: string): string[];
+/**
+ * Find the template directory in the search directories
+ * @returns The path to the template directory or null if not found
+ */
+export declare function findTemplateDir(layer: string, type: string, searchDirs: string[]): Promise<string | null>;
+/**
+ * Read the component template file
+ */
+export declare function readComponentTemplate(templateDir: string): Promise<string>;
+/**
+ * Read the styles template file (optional)
+ * @returns The styles content or empty string if not found
+ */
+export declare function readStylesTemplate(templateDir: string): Promise<string>;
+/**
+ * Load a template for a given layer and type
+ * Orchestrates finding and reading template files
+ */
+export declare function loadTemplate(layer: string, type?: string, customTemplatesDir?: string): Promise<{
+    component: string;
+    styles: string;
+}>;
+export declare function processTemplate(content: string, variables: Record<string, any>): string;
+export declare function listPresets(customTemplatesDir?: string): Promise<string[]>;
+export declare function resolvePresetDir(presetName: string, customTemplatesDir?: string): Promise<string | null>;
+//# sourceMappingURL=templateLoader.d.ts.map

package/dist/lib/templates/templateLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateLoader.d.ts","sourceRoot":"","sources":["../../../src/lib/templates/templateLoader.ts"],"names":[],"mappings":"AAcA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAQzE;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACjC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAexB;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGhF;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAO7E;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAC9B,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,MAAa,EACnB,kBAAkB,CAAC,EAAE,MAAM,GAC5B,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAchD;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAEvF;AAED,wBAAsB,WAAW,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAwBhF;AAED,wBAAsB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiB9G"}