@starodubenko/fsd-gen 0.1.0

package/dist/lib/constants.js

@@ -0,0 +1,129 @@
+/**
+ * FSD Layer names and their plural forms
+ */
+export const FSD_LAYERS = {
+    ENTITY: 'entity',
+    FEATURE: 'feature',
+    WIDGET: 'widget',
+    PAGE: 'page',
+    SHARED: 'shared',
+};
+export const LAYER_PLURALS = {
+    [FSD_LAYERS.ENTITY]: 'entities',
+    [FSD_LAYERS.FEATURE]: 'features',
+    [FSD_LAYERS.WIDGET]: 'widgets',
+    [FSD_LAYERS.PAGE]: 'pages',
+    [FSD_LAYERS.SHARED]: 'shared',
+};
+/**
+ * FSD segment names (directories within slices)
+ */
+export const FSD_SEGMENTS = {
+    UI: 'ui',
+    MODEL: 'model',
+    API: 'api',
+    LIB: 'lib',
+    CONFIG: 'config',
+};
+/**
+ * Template types for different layers
+ */
+export const DEFAULT_TEMPLATES = {
+    [FSD_LAYERS.SHARED]: 'ui-basic',
+    [FSD_LAYERS.ENTITY]: 'model-ui-basic',
+    [FSD_LAYERS.FEATURE]: 'ui-model-basic',
+    [FSD_LAYERS.WIDGET]: 'ui-basic',
+    [FSD_LAYERS.PAGE]: 'ui-basic',
+};
+/**
+ * File extensions
+ */
+export const FILE_EXTENSIONS = {
+    TYPESCRIPT: '.ts',
+    TSX: '.tsx',
+    STYLES: '.styles.ts',
+    JSON: '.json',
+    CONFIG: 'config.ts',
+    INDEX: 'index.ts',
+};
+/**
+ * Configuration file names
+ */
+export const CONFIG_FILES = {
+    FSD_GEN: 'fsdgen.config.ts',
+    PRESET_TS: 'preset.ts',
+    PRESET_JSON: 'preset.json',
+};
+/**
+ * Preset directory names
+ */
+export const PRESET_DIRS = {
+    ROOT: 'preset',
+    BUTTONS: 'buttons',
+    TABLE: 'table',
+};
+/**
+ * API hook operation names
+ */
+export const API_OPERATIONS = {
+    GET: 'get',
+    CREATE: 'create',
+    UPDATE: 'update',
+    DELETE: 'delete',
+};
+/**
+ * API hook name prefixes
+ */
+export const API_HOOK_PREFIXES = {
+    [API_OPERATIONS.GET]: 'useGet',
+    [API_OPERATIONS.CREATE]: 'useCreate',
+    [API_OPERATIONS.UPDATE]: 'useUpdate',
+    [API_OPERATIONS.DELETE]: 'useDelete',
+};
+/**
+ * Default fallback template
+ */
+export const DEFAULT_TEMPLATE = 'ui-basic';
+/**
+ * Default root directory
+ */
+export const DEFAULT_ROOT_DIR = 'src';
+/**
+ * Preset action types
+ */
+export const ACTION_TYPES = {
+    COMPONENT: 'component',
+    FILE: 'file',
+    HOOK: 'hook',
+    STYLES: 'styles',
+};
+/**
+ * Discovery modes
+ */
+export const DISCOVERY_MODES = {
+    AUTO: 'auto',
+    MANUAL: 'manual',
+};
+/**
+ * Naming convention modes
+ */
+export const NAMING_MODES = {
+    ERROR: 'error',
+    WARN: 'warn',
+    AUTO_FIX: 'autoFix',
+};
+/**
+ * Routing configuration constants
+ */
+export const ROUTING = {
+    MARKER: '{/* ROUTES_INJECTION_POINT */}',
+    IMPORTS_REGEX: /^(?:import|export)\s/m,
+    APP_FILE: 'App.tsx',
+};
+/**
+ * Template file names
+ */
+export const TEMPLATE_FILES = {
+    COMPONENT: 'Component.tsx',
+    STYLES: 'Component.styles.ts',
+};

package/dist/lib/generators/generate.d.ts

@@ -0,0 +1,45 @@
+import { FsdPaths } from '../naming/resolvePaths.js';
+import { ACTION_TYPES } from '../constants.js';
+export interface TemplateContext {
+    componentName: string;
+    sliceName: string;
+    layer: string;
+}
+/**
+ * Resolve which template to use for the given layer
+ * @returns Object with templatePath and layerArg for template loading
+ */
+export declare function resolveTemplateType(layer: string, templateOverride?: string): {
+    templatePath: string;
+    layerArg: string;
+};
+/**
+ * Ensure directory exists
+ */
+export declare function ensureDirectory(dir: string): Promise<void>;
+/**
+ * Write component file to disk
+ */
+export declare function writeComponentFile(path: string, content: string): Promise<void>;
+/**
+ * Write styles file to disk (only if content is non-empty)
+ */
+export declare function writeStylesFile(path: string, content: string): Promise<void>;
+/**
+ * Update barrel files for a generated block
+ */
+export declare function updateBarrelsForBlock(slicePath: string, uiPath: string, componentName: string, exportName: string, type: (typeof ACTION_TYPES)[keyof typeof ACTION_TYPES]): void;
+/**
+ * Generate a hook from a template
+ */
+export declare function generateHook(paths: FsdPaths, context: TemplateContext, templatePath: string, templatesDir?: string): Promise<void>;
+/**
+ * Generate styles from a template
+ */
+export declare function generateStyles(paths: FsdPaths, context: TemplateContext, templatePath: string, templatesDir?: string): Promise<void>;
+/**
+ * Generate a component from a template
+ * Orchestrates template loading, rendering, and file writing
+ */
+export declare function generateComponent(paths: FsdPaths, context: TemplateContext, templateOverride?: string, templatesDir?: string): Promise<void>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/lib/generators/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/lib/generators/generate.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAGrD,OAAO,EAAsE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEnH,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAID;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,gBAAgB,CAAC,EAAE,MAAM,GACxB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAO5C;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhE;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGrF;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAKlF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,GACrD,IAAI,CAMN;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,MAAM,iBAatB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,MAAM,iBAYtB;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,eAAe,EACxB,gBAAgB,CAAC,EAAE,MAAM,EACzB,YAAY,CAAC,EAAE,MAAM,iBA2BtB"}

package/dist/lib/generators/generate.js

@@ -0,0 +1,104 @@
+/**
+ * Core generator functions for creating FSD components, slices, and blocks.
+ *
+ * Orchestrates the creation of directories, files, and barrel updates for individual
+ * entities (components, styles, hooks) within a specific layer and slice.
+ */
+import { mkdir, writeFile } from 'fs/promises';
+import { basename } from 'path';
+import { updateBarrel } from '../barrels/updateBarrels.js';
+import { loadTemplate, processTemplate } from '../templates/templateLoader.js';
+import { DEFAULT_TEMPLATES, DEFAULT_TEMPLATE, FSD_SEGMENTS, FILE_EXTENSIONS, ACTION_TYPES } from '../constants.js';
+import { loadConfig } from '../config/loadConfig.js';
+/**
+ * Resolve which template to use for the given layer
+ * @returns Object with templatePath and layerArg for template loading
+ */
+export function resolveTemplateType(layer, templateOverride) {
+    if (templateOverride) {
+        return { templatePath: templateOverride, layerArg: '' };
+    }
+    const templatePath = DEFAULT_TEMPLATES[layer] || DEFAULT_TEMPLATE;
+    return { templatePath, layerArg: layer };
+}
+/**
+ * Ensure directory exists
+ */
+export async function ensureDirectory(dir) {
+    await mkdir(dir, { recursive: true });
+}
+/**
+ * Write component file to disk
+ */
+export async function writeComponentFile(path, content) {
+    await writeFile(path, content);
+    console.log(`Created ${path}`);
+}
+/**
+ * Write styles file to disk (only if content is non-empty)
+ */
+export async function writeStylesFile(path, content) {
+    if (content && content.trim().length > 0) {
+        await writeFile(path, content);
+        console.log(`Created ${path}`);
+    }
+}
+/**
+ * Update barrel files for a generated block
+ */
+export function updateBarrelsForBlock(slicePath, uiPath, componentName, exportName, type) {
+    updateBarrel(uiPath, componentName, exportName);
+    if (type === ACTION_TYPES.COMPONENT || type === ACTION_TYPES.HOOK || type === ACTION_TYPES.STYLES) {
+        updateBarrel(slicePath, FSD_SEGMENTS.UI, FSD_SEGMENTS.UI);
+    }
+}
+/**
+ * Generate a hook from a template
+ */
+export async function generateHook(paths, context, templatePath, templatesDir) {
+    const effectiveTemplatesDir = templatesDir || (await loadConfig()).templatesDir;
+    const { component: hookTemplate } = await loadTemplate('', templatePath, effectiveTemplatesDir);
+    const content = processTemplate(hookTemplate, context);
+    const hookFile = `${paths.componentPath}${FILE_EXTENSIONS.TYPESCRIPT}`;
+    await ensureDirectory(paths.uiPath);
+    await writeFile(hookFile, content);
+    console.log(`Created ${hookFile}`);
+    updateBarrelsForBlock(paths.slicePath, paths.uiPath, context.componentName, context.componentName, ACTION_TYPES.HOOK);
+}
+/**
+ * Generate styles from a template
+ */
+export async function generateStyles(paths, context, templatePath, templatesDir) {
+    const effectiveTemplatesDir = templatesDir || (await loadConfig()).templatesDir;
+    const { styles: stylesTemplate } = await loadTemplate('', templatePath, effectiveTemplatesDir);
+    const content = processTemplate(stylesTemplate, context);
+    const stylesFile = `${paths.componentPath}${FILE_EXTENSIONS.STYLES}`;
+    await ensureDirectory(paths.uiPath);
+    await writeStylesFile(stylesFile, content);
+    updateBarrelsForBlock(paths.slicePath, paths.uiPath, context.componentName, context.componentName, ACTION_TYPES.STYLES);
+}
+/**
+ * Generate a component from a template
+ * Orchestrates template loading, rendering, and file writing
+ */
+export async function generateComponent(paths, context, templateOverride, templatesDir) {
+    // Step 1: Resolve template type
+    const { templatePath, layerArg } = resolveTemplateType(context.layer, templateOverride);
+    console.log(`Using template: ${templateOverride ? templatePath : context.layer + '/' + templatePath}`);
+    // Step 2: Get templates directory
+    const effectiveTemplatesDir = templatesDir || (await loadConfig()).templatesDir;
+    // Step 3: Load template
+    const { component, styles } = await loadTemplate(layerArg, templatePath, effectiveTemplatesDir);
+    // Step 4: Render templates
+    const componentContent = processTemplate(component, context);
+    const stylesContent = processTemplate(styles, context);
+    // Step 5: Write files
+    const componentFile = `${paths.componentPath}${FILE_EXTENSIONS.TSX}`;
+    const stylesFile = `${paths.componentPath}${FILE_EXTENSIONS.STYLES}`;
+    await ensureDirectory(paths.uiPath);
+    await writeComponentFile(componentFile, componentContent);
+    await writeStylesFile(stylesFile, stylesContent);
+    // Step 6: Update barrels
+    const exportName = basename(paths.componentPath);
+    updateBarrelsForBlock(paths.slicePath, paths.uiPath, context.componentName, exportName, ACTION_TYPES.COMPONENT);
+}

package/dist/lib/generators/generatePreset.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generate files from a preset
+ * Main orchestrator function that coordinates all preset generation steps
+ */
+export declare function generatePreset(presetName: string, name: string): Promise<void>;
+//# sourceMappingURL=generatePreset.d.ts.map

package/dist/lib/generators/generatePreset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generatePreset.d.ts","sourceRoot":"","sources":["../../../src/lib/generators/generatePreset.ts"],"names":[],"mappings":"AAmGA;;;GAGG;AACH,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmCpF"}

package/dist/lib/generators/generatePreset.js

@@ -0,0 +1,102 @@
+/**
+ * Generator logic for presets.
+ *
+ * Handles the high-level orchestration of generating complete vertical slices
+ * based on predefined or custom presets. Resolves the preset configuration,
+ * discovers defined actions (files, components), and executes them.
+ */
+/**
+ * Generator logic for presets.
+ *
+ * Handles the high-level orchestration of generating complete vertical slices
+ * based on predefined or custom presets. Resolves the preset configuration,
+ * discovers defined actions (files, components), and executes them.
+ */
+import { resolve } from 'path';
+import { loadConfig } from '../config/loadConfig.js';
+import { resolvePresetDir, processTemplate } from '../templates/templateLoader.js';
+import { loadPresetConfig } from '../preset/presetLoading.js';
+import { discoverTemplates } from '../preset/presetDiscovery.js';
+import { executeActions } from '../preset/actionExecution.js';
+import { injectRoute } from '../routing/injectRoute.js';
+import { DISCOVERY_MODES, ACTION_TYPES, FSD_LAYERS } from '../constants.js';
+/**
+ * Resolve preset actions based on discovery mode
+ */
+async function resolvePresetActions(presetConfig, presetDir, presetName, name) {
+    if (presetConfig.discoveryMode === DISCOVERY_MODES.AUTO) {
+        console.log('Auto-discovering templates...');
+        const discoveredActions = await discoverTemplates(presetDir, presetName, name, presetConfig.conventions);
+        console.log(`Found ${discoveredActions.length} templates`);
+        return discoveredActions;
+    }
+    return presetConfig.actions || [];
+}
+async function handleRouteInjection(presetConfig, actions, name, globalVars, config) {
+    if (!presetConfig.routing) {
+        return;
+    }
+    // Find all page actions
+    const pageActions = actions.filter(action => action.type === ACTION_TYPES.COMPONENT && action.layer === FSD_LAYERS.PAGE);
+    if (pageActions.length === 0) {
+        console.warn('⚠️  Warning: Routing config provided but no page template found');
+        return;
+    }
+    for (const pageAction of pageActions) {
+        // Prepare variables for this specific action
+        const variables = {
+            name,
+            componentName: name,
+            nameLower: name.toLowerCase(),
+            nameUpper: name.toUpperCase(),
+            nameKebab: name.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase(),
+            ...globalVars,
+            ...pageAction.variables
+        };
+        const pageSlice = processTemplate(pageAction.slice, variables);
+        const componentName = presetConfig.routing.componentName ||
+            processTemplate(pageAction.name || pageAction.slice, variables);
+        const importPath = presetConfig.routing.importPath || `@pages/${pageSlice}`;
+        // Support dynamic paths using variables (e.g. /{{name}})
+        const routePath = processTemplate(presetConfig.routing.path, variables);
+        await injectRoute({
+            rootDir: config.rootDir || 'src',
+            path: routePath,
+            importPath,
+            componentName,
+            appFile: presetConfig.routing.appFile
+        });
+    }
+}
+/**
+ * Generate files from a preset
+ * Main orchestrator function that coordinates all preset generation steps
+ */
+export async function generatePreset(presetName, name) {
+    console.log(`Generating preset '${presetName}' for '${name}'...`);
+    // Step 1: Load configuration
+    const config = await loadConfig();
+    const templatesDir = config.templatesDir ? resolve(process.cwd(), config.templatesDir) : undefined;
+    // Step 2: Resolve preset directory
+    const presetDir = await resolvePresetDir(presetName, templatesDir);
+    if (!presetDir) {
+        throw new Error(`Preset '${presetName}' not found`);
+    }
+    // Step 3: Load preset configuration
+    const presetConfig = await loadPresetConfig(presetDir, name, config);
+    if (!presetConfig) {
+        throw new Error(`No preset configuration found in ${presetDir}`);
+    }
+    // Step 4: Determine actions (auto-discovery or manual)
+    const actions = await resolvePresetActions(presetConfig, presetDir, presetName, name);
+    if (!actions || actions.length === 0) {
+        console.warn('No actions found in preset configuration');
+        return;
+    }
+    // Step 5: Execute all actions
+    const globalVars = presetConfig.variables || {};
+    await executeActions(actions, name, globalVars, config);
+    // Step 6: Handle routing injection if configured
+    await handleRouteInjection(presetConfig, actions, name, globalVars, config);
+    console.log('Preset generation complete.');
+}

package/dist/lib/helpers/presetHelpers.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Helper types and interfaces for defining and using presets.
+ *
+ * Provides utility functions for creating preset helpers that standardize naming conventions,
+ * path resolution, and variable generation for preset authors.
+ */
+import { FsdGenConfig } from '../../config/types.js';
+export interface PresetHelpers {
+    /** Base name (same as input name) */
+    baseName: string;
+    /** Import path for entity layer (with or without alias) */
+    entityImportPath: string;
+    /** Feature slice name (e.g., 'ManageUser') */
+    featureSlice: string;
+    /** Import path for feature layer */
+    featureImportPath: string;
+    /** Widget slice name (e.g., 'UserTable') */
+    widgetSlice: string;
+    /** Import path for widget layer */
+    widgetImportPath: string;
+    /** Page slice name (e.g., 'UserPage') */
+    pageSlice: string;
+    /** Import path for page layer */
+    pageImportPath: string;
+}
+export interface PresetHelperOptions {
+    /** Prefix for feature slice names (default: 'Manage') */
+    featurePrefix?: string;
+    /** Suffix for widget slice names (default: 'Table') */
+    widgetSuffix?: string;
+    /** Suffix for page slice names (default: 'Page') */
+    pageSuffix?: string;
+}
+/**
+ * Helper function to resolve import paths and slice names for presets.
+ * Automatically handles FSD layer aliases if configured.
+ *
+ * @param name - The entity name (e.g., 'User', 'Product')
+ * @param config - The loaded FSD generator configuration
+ * @param options - Optional naming conventions
+ * @returns Object with computed import paths and slice names
+ *
+ * @example
+ * ```ts
+ * export default definePreset(({ name, config }) => {
+ *   const helpers = createPresetHelpers(name, config);
+ *   return {
+ *     variables: { ...helpers },
+ *     // ...
+ *   };
+ * });
+ * ```
+ */
+export declare function createPresetHelpers(name: string, config: FsdGenConfig, options?: PresetHelperOptions): PresetHelpers;
+//# sourceMappingURL=presetHelpers.d.ts.map

package/dist/lib/helpers/presetHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presetHelpers.d.ts","sourceRoot":"","sources":["../../../src/lib/helpers/presetHelpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,WAAW,aAAa;IAC1B,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,gBAAgB,EAAE,MAAM,CAAC;IACzB,8CAA8C;IAC9C,YAAY,EAAE,MAAM,CAAC;IACrB,oCAAoC;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,gBAAgB,EAAE,MAAM,CAAC;IACzB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,iCAAiC;IACjC,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAChC,yDAAyD;IACzD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,mBAAwB,GAClC,aAAa,CA0Cf"}

package/dist/lib/helpers/presetHelpers.js

@@ -0,0 +1,53 @@
+/**
+ * Helper function to resolve import paths and slice names for presets.
+ * Automatically handles FSD layer aliases if configured.
+ *
+ * @param name - The entity name (e.g., 'User', 'Product')
+ * @param config - The loaded FSD generator configuration
+ * @param options - Optional naming conventions
+ * @returns Object with computed import paths and slice names
+ *
+ * @example
+ * ```ts
+ * export default definePreset(({ name, config }) => {
+ *   const helpers = createPresetHelpers(name, config);
+ *   return {
+ *     variables: { ...helpers },
+ *     // ...
+ *   };
+ * });
+ * ```
+ */
+export function createPresetHelpers(name, config, options = {}) {
+    const { featurePrefix = 'Manage', widgetSuffix = 'Table', pageSuffix = 'Page' } = options;
+    const aliases = config.aliases || {};
+    const hasEntAlias = !!aliases['@entities'];
+    const hasFeatAlias = !!aliases['@features'];
+    const hasWidgetAlias = !!aliases['@widgets'];
+    const hasPageAlias = !!aliases['@pages'];
+    const entityImportPath = hasEntAlias
+        ? `@entities/${name}`
+        : `../../../entities/${name}`;
+    const featureSlice = `${featurePrefix}${name}`;
+    const featureImportPath = hasFeatAlias
+        ? `@features/${featureSlice}`
+        : `../../../features/${featureSlice}`;
+    const widgetSlice = `${name}${widgetSuffix}`;
+    const widgetImportPath = hasWidgetAlias
+        ? `@widgets/${widgetSlice}`
+        : `../../../widgets/${widgetSlice}`;
+    const pageSlice = `${name}${pageSuffix}`;
+    const pageImportPath = hasPageAlias
+        ? `@pages/${pageSlice}`
+        : `../../../pages/${pageSlice}`;
+    return {
+        baseName: name,
+        entityImportPath,
+        featureSlice,
+        featureImportPath,
+        widgetSlice,
+        widgetImportPath,
+        pageSlice,
+        pageImportPath
+    };
+}

package/dist/lib/naming/names.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Naming utility functions.
+ *
+ * Provides standard functions for string manipulation, such as converting strings
+ * to PascalCase for component names or handling other case conversions required by FSD.
+ */
+export declare function toPascalCase(str: string): string;
+export declare function toCamelCase(str: string): string;
+export declare function toKebabCase(str: string): string;
+//# sourceMappingURL=names.d.ts.map

package/dist/lib/naming/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../../src/lib/naming/names.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C"}

package/dist/lib/naming/names.js

@@ -0,0 +1,15 @@
+/**
+ * Naming utility functions.
+ *
+ * Provides standard functions for string manipulation, such as converting strings
+ * to PascalCase for component names or handling other case conversions required by FSD.
+ */
+export function toPascalCase(str) {
+    return str.replace(/(^\w|-\w)/g, (clear) => clear.replace(/-/, '').toUpperCase());
+}
+export function toCamelCase(str) {
+    return str.replace(/-\w/g, (clear) => clear[1].toUpperCase());
+}
+export function toKebabCase(str) {
+    return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+}

package/dist/lib/naming/resolvePaths.d.ts

@@ -0,0 +1,33 @@
+export interface FsdPaths {
+    layerPath: string;
+    slicePath: string;
+    uiPath: string;
+    componentPath: string;
+}
+/**
+ * Map layer name to plural directory name
+ */
+export declare function getLayerPlural(layer: string): string;
+/**
+ * Build the full path to the layer directory
+ */
+export declare function buildLayerPath(rootDir: string, layer: string): string;
+/**
+ * Build the path to the slice directory
+ */
+export declare function buildSlicePath(layerPath: string, slice: string): string;
+/**
+ * Build the path to the UI directory
+ * Handles special case for shared layer (no extra ui folder)
+ */
+export declare function buildUiPath(slicePath: string, layer: string): string;
+/**
+ * Build the path to the component directory
+ */
+export declare function buildComponentPath(uiPath: string, componentName: string): string;
+/**
+ * Resolve all FSD paths for a component
+ * Orchestrates building individual path segments
+ */
+export declare function resolveFsdPaths(rootDir: string, layer: string, slice: string, componentName: string): FsdPaths;
+//# sourceMappingURL=resolvePaths.d.ts.map

package/dist/lib/naming/resolvePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePaths.d.ts","sourceRoot":"","sources":["../../../src/lib/naming/resolvePaths.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,QAAQ;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAEhF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACtB,QAAQ,CAcV"}

package/dist/lib/naming/resolvePaths.js

@@ -0,0 +1,58 @@
+/**
+ * FSD path resolution logic.
+ *
+ * Determines the correct file system paths for entities based on their layer, slice,
+ * and name. Handles the structural rules of Feature-Sliced Design (e.g. shared vs page vs entity).
+ */
+import { join } from 'path';
+import { LAYER_PLURALS, FSD_SEGMENTS, FSD_LAYERS } from '../constants.js';
+/**
+ * Map layer name to plural directory name
+ */
+export function getLayerPlural(layer) {
+    return LAYER_PLURALS[layer] || layer;
+}
+/**
+ * Build the full path to the layer directory
+ */
+export function buildLayerPath(rootDir, layer) {
+    const layerDir = getLayerPlural(layer);
+    return join(rootDir, layerDir);
+}
+/**
+ * Build the path to the slice directory
+ */
+export function buildSlicePath(layerPath, slice) {
+    return join(layerPath, slice);
+}
+/**
+ * Build the path to the UI directory
+ * Handles special case for shared layer (no extra ui folder)
+ */
+export function buildUiPath(slicePath, layer) {
+    const isShared = layer === FSD_LAYERS.SHARED;
+    return isShared ? slicePath : join(slicePath, FSD_SEGMENTS.UI);
+}
+/**
+ * Build the path to the component directory
+ */
+export function buildComponentPath(uiPath, componentName) {
+    return join(uiPath, componentName);
+}
+/**
+ * Resolve all FSD paths for a component
+ * Orchestrates building individual path segments
+ */
+export function resolveFsdPaths(rootDir, layer, slice, componentName) {
+    const layerPath = buildLayerPath(rootDir, layer);
+    const slicePath = buildSlicePath(layerPath, slice);
+    const uiPath = buildUiPath(slicePath, layer);
+    const componentPath = buildComponentPath(uiPath, componentName);
+    console.log('ResolvePaths:', { layer, slice, componentName, isShared: layer === FSD_LAYERS.SHARED, uiPath, componentPath });
+    return {
+        layerPath,
+        slicePath,
+        uiPath,
+        componentPath,
+    };
+}

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

@@ -0,0 +1,32 @@
+import { PresetAction, PresetComponentAction, PresetFileAction, FsdGenConfig } from '../../config/types.js';
+/**
+ * Prepare variables for an action by merging global and action-specific variables
+ */
+export declare function prepareActionVariables(action: PresetAction, name: string, globalVars: Record<string, any>): Record<string, any>;
+/**
+ * Execute a component action (generate a component)
+ */
+export declare function executeComponentAction(action: PresetComponentAction, variables: Record<string, any>, config: FsdGenConfig): Promise<void>;
+/**
+ * Execute a hook action
+ */
+export declare function executeHookAction(action: any, // Using any for now to avoid complexity with union types in loop
+variables: Record<string, any>, config: FsdGenConfig): Promise<void>;
+/**
+ * Execute a styles action
+ */
+export declare function executeStylesAction(action: any, variables: Record<string, any>, config: FsdGenConfig): Promise<void>;
+/**
+ * Load a file template from the templates directory
+ */
+export declare function loadFileTemplate(templatePath: string, customTemplatesDir?: string): Promise<string>;
+/**
+ * Execute a file action (create a file from template)
+ */
+export declare function executeFileAction(action: PresetFileAction, variables: Record<string, any>, config: FsdGenConfig): Promise<void>;
+/**
+ * Execute all preset actions
+ * Orchestrates executing component and file actions
+ */
+export declare function executeActions(actions: PresetAction[], name: string, globalVars: Record<string, any>, config: FsdGenConfig): Promise<void>;
+//# sourceMappingURL=actionExecution.d.ts.map