@validkeys/ollypop-ts/dist/types.js

Automatic TypeScript barrel file generator CLI.

import { z } from 'zod';
export const SourceConfigSchema = z.object({
    path: z.string(),
    recursive: z.boolean().optional().default(false),
    maxDepth: z.number().optional(),
    pattern: z.string().optional().default('*.ts'),
    directoryPattern: z.boolean().optional().default(false),
    indexFile: z.string().optional().default('index.js'),
});
export const MarkerConfigSchema = z.object({
    startMarker: z.string(),
    endMarker: z.string(),
    preserveContent: z.boolean().optional().default(true),
});
export const ExportConfigSchema = z.object({
    style: z.enum(['named', 'default', 'namespace', 'reexport', 'mixed']),
    defaultExports: z.enum(['ignore', 'named', 'passthrough']).optional().default('ignore'),
    naming: z
        .object({
        transform: z.enum(['kebab', 'camel', 'pascal', 'preserve']).optional().default('preserve'),
        prefix: z.string().optional(),
        suffix: z.string().optional(),
    })
        .optional(),
    groupByDirectory: z.boolean().optional().default(false),
    sort: z.boolean().optional().default(true),
});
function validateExportTemplate(template) {
    if (!template.includes('export') || !template.includes('from')) {
        throw new Error(`Export template must be a valid export statement. Expected format: export * from "./path/{variable}" or export * as Name from "./path/{variable}"`);
    }
    const fromClauseMatch = template.match(/from\s+(['"]?)([^'"\s]+)(['"]?)/);
    if (!fromClauseMatch) {
        throw new Error(`Invalid export statement. Expected format: export * from "./path/{variable}" or export * as Name from "./path/{variable}"`);
    }
    const [, openQuote, pathContent, closeQuote] = fromClauseMatch;
    if (!openQuote || !closeQuote) {
        throw new Error(`Path in export template must be enclosed in quotes. Found: ${pathContent}\nCorrect format: export * from "./path/{variable}" or export * from './path/{variable}'`);
    }
    if (openQuote !== closeQuote) {
        throw new Error(`Mismatched quotes in export template. Opening quote '${openQuote}' does not match closing quote '${closeQuote}'.\nUse matching single quotes ('...') or double quotes ("...")`);
    }
    if (!pathContent.includes('{') || !pathContent.includes('}')) {
        throw new Error(`Export template path must contain at least one variable in curly braces {variable}. Found path: ${pathContent}`);
    }
    return template;
}
export const TemplateConfigSchema = z.object({
    name: z.string(),
    export: z.string().refine(validateExportTemplate, {
        message: "Invalid export template syntax"
    }),
    mode: z.enum(['replace', 'partial-replace']).default('replace'),
    requiredFile: z.string().optional(),
});
export const ProcessingOptionsSchema = z.object({
    followSymlinks: z.boolean().default(false),
    preserveExtensions: z.boolean().default(false),
    extensions: z.array(z.string()).default(['.ts', '.tsx']),
    validateExports: z.boolean().default(false),
    dryRun: z.boolean().default(false),
});
export const GenerationOptionsSchema = z
    .object({
    namedExports: z.boolean().default(true),
    preserveExtensions: z.boolean().default(false),
    sortExports: z.boolean().default(true),
    addBanner: z.boolean().default(true),
    customBanner: z.string().optional(),
    verbose: z.boolean().default(false),
})
    .strict();
export const VariableBarrelDefinitionSchema = z.object({
    name: z.string(),
    output: z.string(),
    template: TemplateConfigSchema,
    exclude: z.array(z.string()).optional(),
    options: z
        .object({
        preserveExtensions: z.boolean().default(true),
        extensions: z.array(z.string()).default(['.ts']),
        validateExports: z.boolean().default(false),
        dryRun: z.boolean().default(false),
    })
        .optional(),
});
export const BarrelDefinitionSchema = VariableBarrelDefinitionSchema;
export const BarrelConfigSchema = z.object({
    version: z.string(),
    barrels: z.array(BarrelDefinitionSchema),
    globalOptions: ProcessingOptionsSchema.optional(),
});
export function isVariableBarrelDefinition(def) {
    return def.template?.name === 'variable-template';
}
//# sourceMappingURL=types.js.map