@baseplate-dev/core-generators 0.1.3 → 0.2.1

package/dist/renderers/raw/raw-template-file-extractor.d.ts

@@ -0,0 +1,164 @@
+export declare const RawTemplateFileExtractor: import("@baseplate-dev/sync").TemplateFileExtractor<import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    name: import("zod").ZodString;
+    type: import("zod").ZodString;
+}, {
+    fileOptions: import("zod").ZodDefault<import("zod").ZodDiscriminatedUnion<"kind", [import("zod").ZodObject<{
+        kind: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"singleton">>>;
+        generatorTemplatePath: import("zod").ZodOptional<import("zod").ZodString>;
+        pathRootRelativePath: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }, {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"instance">;
+        generatorTemplatePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }>]>>;
+    pathRootRelativePath: import("zod").ZodOptional<import("zod").ZodString>;
+}>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+    name: import("zod").ZodString;
+    type: import("zod").ZodString;
+}, {
+    fileOptions: import("zod").ZodDefault<import("zod").ZodDiscriminatedUnion<"kind", [import("zod").ZodObject<{
+        kind: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"singleton">>>;
+        generatorTemplatePath: import("zod").ZodOptional<import("zod").ZodString>;
+        pathRootRelativePath: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }, {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"instance">;
+        generatorTemplatePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }>]>>;
+    pathRootRelativePath: import("zod").ZodOptional<import("zod").ZodString>;
+}>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+    name: import("zod").ZodString;
+    type: import("zod").ZodString;
+}, {
+    fileOptions: import("zod").ZodDefault<import("zod").ZodDiscriminatedUnion<"kind", [import("zod").ZodObject<{
+        kind: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"singleton">>>;
+        generatorTemplatePath: import("zod").ZodOptional<import("zod").ZodString>;
+        pathRootRelativePath: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }, {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"instance">;
+        generatorTemplatePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }>]>>;
+    pathRootRelativePath: import("zod").ZodOptional<import("zod").ZodString>;
+}>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    name: import("zod").ZodString;
+    type: import("zod").ZodString;
+    generator: import("zod").ZodString;
+}, {
+    type: import("zod").ZodLiteral<"raw">;
+    fileOptions: import("zod").ZodDefault<import("zod").ZodDiscriminatedUnion<"kind", [import("zod").ZodObject<{
+        kind: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"singleton">>>;
+        generatorTemplatePath: import("zod").ZodOptional<import("zod").ZodString>;
+        pathRootRelativePath: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }, {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"instance">;
+        generatorTemplatePath: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }>]>>;
+}>, "strip", import("zod").ZodTypeAny, {
+    type: "raw";
+    name: string;
+    fileOptions: {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    } | {
+        kind: "instance";
+        generatorTemplatePath: string;
+    };
+    generator: string;
+}, {
+    type: "raw";
+    name: string;
+    generator: string;
+    fileOptions?: {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    } | {
+        kind: "instance";
+        generatorTemplatePath: string;
+    } | undefined;
+}>, import("zod").ZodUnknown, (import("@baseplate-dev/sync").TemplateExtractorPlugin<"template-paths", {
+    getPathRootRelativePath: (absolutePath: string) => string;
+    getTemplatePathFromPathRootRelativePath: (pathRootRelativePath: string) => string;
+    registerTemplatePathEntry: (generatorName: string, templateName: string, pathRootRelativePath: string) => void;
+    resolveTemplatePaths: (fileOptions: import("../schemas/template-file-options.js").TemplateFileOptions, absolutePath: string, templateName: string, generatorName: string) => {
+        pathRootRelativePath: string | undefined;
+        generatorTemplatePath: string;
+    };
+    getPathsRootExportName: (generatorName: string) => string;
+}, import("@baseplate-dev/sync").TemplateExtractorPlugin<"barrel-export", {
+    addBarrelExport: (generatorName: string, barrelExport: import("../extractors.js").TemplateExtractorBarrelExport) => void;
+    addGeneratedBarrelExport: (generatorName: string, generatedBarrelExport: import("../extractors.js").TemplateExtractorGeneratedBarrelExport) => void;
+}, []>[]> | import("@baseplate-dev/sync").TemplateExtractorPlugin<"typed-templates-file", {
+    addTemplate: (generatorName: string, template: import("../extractor/plugins/typed-templates-file.js").TemplateExtractorTypedTemplate) => void;
+}, (import("@baseplate-dev/sync").TemplateExtractorPlugin<"barrel-export", {
+    addBarrelExport: (generatorName: string, barrelExport: import("../extractors.js").TemplateExtractorBarrelExport) => void;
+    addGeneratedBarrelExport: (generatorName: string, generatedBarrelExport: import("../extractors.js").TemplateExtractorGeneratedBarrelExport) => void;
+}, []> | import("@baseplate-dev/sync").TemplateExtractorPlugin<"template-paths", {
+    getPathRootRelativePath: (absolutePath: string) => string;
+    getTemplatePathFromPathRootRelativePath: (pathRootRelativePath: string) => string;
+    registerTemplatePathEntry: (generatorName: string, templateName: string, pathRootRelativePath: string) => void;
+    resolveTemplatePaths: (fileOptions: import("../schemas/template-file-options.js").TemplateFileOptions, absolutePath: string, templateName: string, generatorName: string) => {
+        pathRootRelativePath: string | undefined;
+        generatorTemplatePath: string;
+    };
+    getPathsRootExportName: (generatorName: string) => string;
+}, import("@baseplate-dev/sync").TemplateExtractorPlugin<"barrel-export", {
+    addBarrelExport: (generatorName: string, barrelExport: import("../extractors.js").TemplateExtractorBarrelExport) => void;
+    addGeneratedBarrelExport: (generatorName: string, generatedBarrelExport: import("../extractors.js").TemplateExtractorGeneratedBarrelExport) => void;
+}, []>[]>)[]>)[], unknown>;
+//# sourceMappingURL=raw-template-file-extractor.d.ts.map

package/dist/renderers/raw/raw-template-file-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-template-file-extractor.d.ts","sourceRoot":"","sources":["../../../src/renderers/raw/raw-template-file-extractor.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA0GnC,CAAC"}

package/dist/renderers/raw/raw-template-file-extractor.js

@@ -0,0 +1,79 @@
+import { createTemplateFileExtractor, getGenerationConcurrencyLimit, } from '@baseplate-dev/sync';
+import { camelCase } from 'change-case';
+import pLimit from 'p-limit';
+import { templatePathsPlugin } from '../extractor/plugins/template-paths/template-paths.plugin.js';
+import { typedTemplatesFilePlugin } from '../extractor/plugins/typed-templates-file.js';
+import { deduplicateTemplateFileExtractorSourceFiles } from '../extractor/utils/deduplicate-templates.js';
+import { resolvePackagePathSpecifier } from '../extractor/utils/package-path-specifier.js';
+import { TsCodeUtils, tsImportBuilder } from '../typescript/index.js';
+import { rawTemplateGeneratorTemplateMetadataSchema, rawTemplateOutputTemplateMetadataSchema, } from './types.js';
+const limit = pLimit(getGenerationConcurrencyLimit());
+export const RawTemplateFileExtractor = createTemplateFileExtractor({
+    name: 'raw',
+    pluginDependencies: [templatePathsPlugin, typedTemplatesFilePlugin],
+    outputTemplateMetadataSchema: rawTemplateOutputTemplateMetadataSchema,
+    generatorTemplateMetadataSchema: rawTemplateGeneratorTemplateMetadataSchema,
+    extractTemplateMetadataEntries: (files, context) => {
+        const deduplicatedFiles = deduplicateTemplateFileExtractorSourceFiles(files);
+        const templatePathPlugin = context.getPlugin('template-paths');
+        return deduplicatedFiles.map(({ metadata, absolutePath }) => {
+            try {
+                const { pathRootRelativePath, generatorTemplatePath } = templatePathPlugin.resolveTemplatePaths(metadata.fileOptions, absolutePath, metadata.name, metadata.generator);
+                return {
+                    generator: metadata.generator,
+                    generatorTemplatePath,
+                    sourceAbsolutePath: absolutePath,
+                    metadata: {
+                        name: metadata.name,
+                        type: metadata.type,
+                        fileOptions: metadata.fileOptions,
+                        pathRootRelativePath,
+                    },
+                };
+            }
+            catch (error) {
+                throw new Error(`Error extracting template metadata for ${absolutePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+            }
+        });
+    },
+    writeTemplateFiles: async (files, _context, api) => {
+        await Promise.all(files.map((file) => limit(async () => {
+            try {
+                const contents = await api.readOutputFileBuffer(file.sourceAbsolutePath);
+                await api.writeTemplateFile(file.generator, file.generatorTemplatePath, contents);
+            }
+            catch (error) {
+                throw new Error(`Error writing template file for ${file.sourceAbsolutePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+            }
+        })));
+    },
+    writeGeneratedFiles: (generatorNames, context) => {
+        const templatePathsPlugin = context.getPlugin('template-paths');
+        const typedTemplatesPlugin = context.getPlugin('typed-templates-file');
+        for (const generatorName of generatorNames) {
+            const generatorConfig = context.configLookup.getExtractorConfigOrThrow(generatorName);
+            const templates = context.configLookup.getTemplatesForGenerator(generatorName, rawTemplateGeneratorTemplateMetadataSchema, 'raw');
+            for (const { path, config } of templates) {
+                const exportName = camelCase(config.name);
+                const fragment = TsCodeUtils.templateWithImports([
+                    tsImportBuilder(['createRawTemplateFile']).from(resolvePackagePathSpecifier('@baseplate-dev/core-generators:src/renderers/raw/types.ts', generatorConfig.packageName)),
+                    tsImportBuilder().default('path').from('node:path'),
+                ]) `const ${exportName} = createRawTemplateFile({
+          name: '${config.name}',
+          source: {
+            path: path.join(import.meta.dirname, '../templates/${path}'),
+          },
+          fileOptions: ${JSON.stringify(config.fileOptions)},
+        });`;
+                typedTemplatesPlugin.addTemplate(generatorName, {
+                    exportName,
+                    fragment,
+                });
+                if (config.pathRootRelativePath) {
+                    templatePathsPlugin.registerTemplatePathEntry(generatorName, config.name, config.pathRootRelativePath);
+                }
+            }
+        }
+    },
+});
+//# sourceMappingURL=raw-template-file-extractor.js.map

package/dist/renderers/raw/raw-template-file-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-template-file-extractor.js","sourceRoot":"","sources":["../../../src/renderers/raw/raw-template-file-extractor.ts"],"names":[],"mappings":"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"}

package/dist/renderers/raw/render-raw-template-action.d.ts

@@ -0,0 +1,15 @@
+import type { BuilderAction, WriteFileOptions } from '@baseplate-dev/sync';
+import type { RawTemplateFile } from './types.js';
+interface RenderRawTemplateFileActionInputBase<TemplateFile extends RawTemplateFile> {
+    template: TemplateFile;
+    destination: string;
+    options?: Omit<WriteFileOptions, 'templateMetadata'>;
+}
+type RenderRawTemplateFileActionInput<TTemplateFile extends RawTemplateFile> = RenderRawTemplateFileActionInputBase<TTemplateFile> & (TTemplateFile['fileOptions']['kind'] extends 'singleton' ? {
+    id?: undefined;
+} : {
+    id: string;
+});
+export declare function renderRawTemplateFileAction<TTemplateFile extends RawTemplateFile>({ template, id, destination, options, }: RenderRawTemplateFileActionInput<TTemplateFile>): BuilderAction;
+export {};
+//# sourceMappingURL=render-raw-template-action.d.ts.map

package/dist/renderers/raw/render-raw-template-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-raw-template-action.d.ts","sourceRoot":"","sources":["../../../src/renderers/raw/render-raw-template-action.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAI3E,OAAO,KAAK,EACV,eAAe,EAEhB,MAAM,YAAY,CAAC;AAIpB,UAAU,oCAAoC,CAC5C,YAAY,SAAS,eAAe;IAEpC,QAAQ,EAAE,YAAY,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;CACtD;AAED,KAAK,gCAAgC,CAAC,aAAa,SAAS,eAAe,IACzE,oCAAoC,CAAC,aAAa,CAAC,GACjD,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,SAAS,WAAW,GACrD;IAAE,EAAE,CAAC,EAAE,SAAS,CAAA;CAAE,GAClB;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAExB,wBAAgB,2BAA2B,CACzC,aAAa,SAAS,eAAe,EACrC,EACA,QAAQ,EACR,EAAE,EACF,WAAW,EACX,OAAO,GACR,EAAE,gCAAgC,CAAC,aAAa,CAAC,GAAG,aAAa,CA0CjE"}

package/dist/renderers/raw/render-raw-template-action.js

@@ -0,0 +1,39 @@
+import { readTemplateFileSourceBuffer } from '@baseplate-dev/sync';
+import { RAW_TEMPLATE_TYPE } from './types.js';
+export function renderRawTemplateFileAction({ template, id, destination, options, }) {
+    return {
+        execute: async (builder) => {
+            const source = await readTemplateFileSourceBuffer(template.source);
+            if (template.fileOptions.kind === 'instance' && !id) {
+                throw new Error('Instance template must have an id');
+            }
+            const fileId = id ?? template.name;
+            const shouldWriteMetadata = builder.metadataOptions.includeTemplateMetadata &&
+                builder.metadataOptions.shouldGenerateMetadata({
+                    fileId,
+                    filePath: destination,
+                    generatorName: builder.generatorInfo.name,
+                    isInstance: template.fileOptions.kind === 'instance',
+                });
+            const templateMetadata = 'path' in template.source
+                ? {
+                    generator: builder.generatorInfo.name,
+                    type: RAW_TEMPLATE_TYPE,
+                    name: template.name,
+                    fileOptions: template.fileOptions,
+                }
+                : undefined;
+            builder.writeFile({
+                id: fileId,
+                destination,
+                contents: source,
+                options: {
+                    skipFormatting: true,
+                    ...options,
+                },
+                templateMetadata: shouldWriteMetadata ? templateMetadata : undefined,
+            });
+        },
+    };
+}
+//# sourceMappingURL=render-raw-template-action.js.map

package/dist/renderers/raw/render-raw-template-action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-raw-template-action.js","sourceRoot":"","sources":["../../../src/renderers/raw/render-raw-template-action.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAOnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAgB/C,MAAM,UAAU,2BAA2B,CAEzC,EACA,QAAQ,EACR,EAAE,EACF,WAAW,EACX,OAAO,GACyC;IAChD,OAAO;QACL,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;YACzB,MAAM,MAAM,GAAG,MAAM,4BAA4B,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAEnE,IAAI,QAAQ,CAAC,WAAW,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,EAAE,EAAE,CAAC;gBACpD,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;YACvD,CAAC;YAED,MAAM,MAAM,GAAG,EAAE,IAAI,QAAQ,CAAC,IAAI,CAAC;YAEnC,MAAM,mBAAmB,GACvB,OAAO,CAAC,eAAe,CAAC,uBAAuB;gBAC/C,OAAO,CAAC,eAAe,CAAC,sBAAsB,CAAC;oBAC7C,MAAM;oBACN,QAAQ,EAAE,WAAW;oBACrB,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC,IAAI;oBACzC,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,IAAI,KAAK,UAAU;iBACrD,CAAC,CAAC;YAEL,MAAM,gBAAgB,GACpB,MAAM,IAAI,QAAQ,CAAC,MAAM;gBACvB,CAAC,CAAC;oBACE,SAAS,EAAE,OAAO,CAAC,aAAa,CAAC,IAAI;oBACrC,IAAI,EAAE,iBAAiB;oBACvB,IAAI,EAAE,QAAQ,CAAC,IAAI;oBACnB,WAAW,EAAE,QAAQ,CAAC,WAAW;iBAClC;gBACH,CAAC,CAAC,SAAS,CAAC;YAEhB,OAAO,CAAC,SAAS,CAAC;gBAChB,EAAE,EAAE,MAAM;gBACV,WAAW;gBACX,QAAQ,EAAE,MAAM;gBAChB,OAAO,EAAE;oBACP,cAAc,EAAE,IAAI;oBACpB,GAAG,OAAO;iBACX;gBACD,gBAAgB,EAAE,mBAAmB,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS;aACrE,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/renderers/raw/types.d.ts

@@ -0,0 +1,178 @@
+import type { TemplateFileBase } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import type { TemplateFileOptions } from '../schemas/template-file-options.js';
+export declare const RAW_TEMPLATE_TYPE = "raw";
+export declare const rawTemplateGeneratorTemplateMetadataSchema: z.ZodObject<z.objectUtil.extendShape<{
+    name: z.ZodString;
+    type: z.ZodString;
+}, {
+    /**
+     * The options for the template file
+     */
+    fileOptions: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"singleton">>>;
+        generatorTemplatePath: z.ZodOptional<z.ZodString>;
+        pathRootRelativePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }, {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"instance">;
+        generatorTemplatePath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }>]>>;
+    /**
+     * The path of the template relative to the closest file path root.
+     */
+    pathRootRelativePath: z.ZodOptional<z.ZodString>;
+}>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+    name: z.ZodString;
+    type: z.ZodString;
+}, {
+    /**
+     * The options for the template file
+     */
+    fileOptions: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"singleton">>>;
+        generatorTemplatePath: z.ZodOptional<z.ZodString>;
+        pathRootRelativePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }, {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"instance">;
+        generatorTemplatePath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }>]>>;
+    /**
+     * The path of the template relative to the closest file path root.
+     */
+    pathRootRelativePath: z.ZodOptional<z.ZodString>;
+}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+    name: z.ZodString;
+    type: z.ZodString;
+}, {
+    /**
+     * The options for the template file
+     */
+    fileOptions: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"singleton">>>;
+        generatorTemplatePath: z.ZodOptional<z.ZodString>;
+        pathRootRelativePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }, {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"instance">;
+        generatorTemplatePath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }>]>>;
+    /**
+     * The path of the template relative to the closest file path root.
+     */
+    pathRootRelativePath: z.ZodOptional<z.ZodString>;
+}>, z.ZodTypeAny, "passthrough">>;
+export declare const rawTemplateOutputTemplateMetadataSchema: z.ZodObject<z.objectUtil.extendShape<{
+    name: z.ZodString;
+    type: z.ZodString;
+    generator: z.ZodString;
+}, {
+    /**
+     * The type of the template (always `raw`)
+     */
+    type: z.ZodLiteral<"raw">;
+    /**
+     * The options for the template file
+     */
+    fileOptions: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"singleton">>>;
+        generatorTemplatePath: z.ZodOptional<z.ZodString>;
+        pathRootRelativePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }, {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"instance">;
+        generatorTemplatePath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }, {
+        kind: "instance";
+        generatorTemplatePath: string;
+    }>]>>;
+}>, "strip", z.ZodTypeAny, {
+    type: "raw";
+    name: string;
+    fileOptions: {
+        kind: "singleton";
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    } | {
+        kind: "instance";
+        generatorTemplatePath: string;
+    };
+    generator: string;
+}, {
+    type: "raw";
+    name: string;
+    generator: string;
+    fileOptions?: {
+        kind?: "singleton" | undefined;
+        generatorTemplatePath?: string | undefined;
+        pathRootRelativePath?: string | undefined;
+    } | {
+        kind: "instance";
+        generatorTemplatePath: string;
+    } | undefined;
+}>;
+/**
+ * Metadata for a raw template file
+ */
+export type RawTemplateOutputTemplateMetadata = z.infer<typeof rawTemplateOutputTemplateMetadataSchema>;
+/**
+ * A template for a raw file with no replacements.
+ */
+export interface RawTemplateFile<TFileOptions extends TemplateFileOptions = TemplateFileOptions> extends TemplateFileBase {
+    fileOptions: TFileOptions;
+}
+/**
+ * Create a raw template file
+ */
+export declare function createRawTemplateFile<TFileOptions extends TemplateFileOptions>(templateFile: RawTemplateFile<TFileOptions>): RawTemplateFile<TFileOptions>;
+//# sourceMappingURL=types.d.ts.map

package/dist/renderers/raw/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/renderers/raw/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAM5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAI/E,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AAEvC,eAAO,MAAM,0CAA0C;UANxB,EAAG,SAAS;UAE6B,EAAG,SAEzE;;IAIE;;OAEG;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;UAdwB,EAAG,SAAS;UAE6B,EAAG,SAEzE;;IAIE;;OAEG;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;UAdwB,EAAG,SAAS;UAE6B,EAAG,SAEzE;;IAIE;;OAEG;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;iCAEH,CAAC;AAEL,eAAO,MAAM,uCAAuC;UAlBnD,EAAG,SAAS;UAEH,EAAG,SAAS;eAEM,EAAG,SAC/B;;IAeI;;OAEG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEL;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,eAAe,CAC9B,YAAY,SAAS,mBAAmB,GAAG,mBAAmB,CAC9D,SAAQ,gBAAgB;IACxB,WAAW,EAAE,YAAY,CAAC;CAC3B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,SAAS,mBAAmB,EAC5E,YAAY,EAAE,eAAe,CAAC,YAAY,CAAC,GAC1C,eAAe,CAAC,YAAY,CAAC,CAE/B"}

package/dist/renderers/raw/types.js

@@ -0,0 +1,31 @@
+import { templateConfigSchema, templateFileMetadataBaseSchema, } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import { templateFileOptionsSchema } from '../schemas/template-file-options.js';
+export const RAW_TEMPLATE_TYPE = 'raw';
+export const rawTemplateGeneratorTemplateMetadataSchema = templateConfigSchema.extend({
+    /**
+     * The options for the template file
+     */
+    fileOptions: templateFileOptionsSchema,
+    /**
+     * The path of the template relative to the closest file path root.
+     */
+    pathRootRelativePath: z.string().optional(),
+});
+export const rawTemplateOutputTemplateMetadataSchema = templateFileMetadataBaseSchema.extend({
+    /**
+     * The type of the template (always `raw`)
+     */
+    type: z.literal(RAW_TEMPLATE_TYPE),
+    /**
+     * The options for the template file
+     */
+    fileOptions: templateFileOptionsSchema,
+});
+/**
+ * Create a raw template file
+ */
+export function createRawTemplateFile(templateFile) {
+    return templateFile;
+}
+//# sourceMappingURL=types.js.map

package/dist/renderers/raw/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/renderers/raw/types.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,oBAAoB,EACpB,8BAA8B,GAC/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAEhF,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,CAAC;AAEvC,MAAM,CAAC,MAAM,0CAA0C,GACrD,oBAAoB,CAAC,MAAM,CAAC;IAC1B;;OAEG;IACH,WAAW,EAAE,yBAAyB;IACtC;;OAEG;IACH,oBAAoB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC5C,CAAC,CAAC;AAEL,MAAM,CAAC,MAAM,uCAAuC,GAClD,8BAA8B,CAAC,MAAM,CAAC;IACpC;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC;IAClC;;OAEG;IACH,WAAW,EAAE,yBAAyB;CACvC,CAAC,CAAC;AAkBL;;GAEG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAA2C;IAE3C,OAAO,YAAY,CAAC;AACtB,CAAC"}

package/dist/renderers/schemas/template-file-options.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const templateFileOptionsSchema: z.ZodDefault<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"singleton">>>;
+    /**
+     * The path of the template in the generator's `templates/` directory.
+     *
+     * Defaults to template path if not provided.
+     */
+    generatorTemplatePath: z.ZodOptional<z.ZodString>;
+    /**
+     * The path root relative path of the template.
+     *
+     * This overrides the default detected path root relative path and should be used sparingly, e.g.
+     * in cases where you want to override the default path root relative path for a singleton template.
+     */
+    pathRootRelativePath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "singleton";
+    generatorTemplatePath?: string | undefined;
+    pathRootRelativePath?: string | undefined;
+}, {
+    kind?: "singleton" | undefined;
+    generatorTemplatePath?: string | undefined;
+    pathRootRelativePath?: string | undefined;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"instance">;
+    /**
+     * The path of the template in the generator's `templates/` directory.
+     */
+    generatorTemplatePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "instance";
+    generatorTemplatePath: string;
+}, {
+    kind: "instance";
+    generatorTemplatePath: string;
+}>]>>;
+export type TemplateFileOptions = z.infer<typeof templateFileOptionsSchema>;
+//# sourceMappingURL=template-file-options.d.ts.map

package/dist/renderers/schemas/template-file-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-file-options.d.ts","sourceRoot":"","sources":["../../../src/renderers/schemas/template-file-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,yBAAyB;;IAIhC;;;;OAIG;;IAEH;;;;;OAKG;;;;;;;;;;;;IAKH;;OAEG;;;;;;;;KAIwB,CAAC;AAElC,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/renderers/schemas/template-file-options.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export const templateFileOptionsSchema = z
+    .discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('singleton').optional().default('singleton'),
+        /**
+         * The path of the template in the generator's `templates/` directory.
+         *
+         * Defaults to template path if not provided.
+         */
+        generatorTemplatePath: z.string().optional(),
+        /**
+         * The path root relative path of the template.
+         *
+         * This overrides the default detected path root relative path and should be used sparingly, e.g.
+         * in cases where you want to override the default path root relative path for a singleton template.
+         */
+        pathRootRelativePath: z.string().optional(),
+    }),
+    z.object({
+        kind: z.literal('instance'),
+        /**
+         * The path of the template in the generator's `templates/` directory.
+         */
+        generatorTemplatePath: z.string(),
+    }),
+])
+    .default({ kind: 'singleton' });
+//# sourceMappingURL=template-file-options.js.map

package/dist/renderers/schemas/template-file-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-file-options.js","sourceRoot":"","sources":["../../../src/renderers/schemas/template-file-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC;KACvC,kBAAkB,CAAC,MAAM,EAAE;IAC1B,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC;QAC5D;;;;WAIG;QACH,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC5C;;;;;WAKG;QACH,oBAAoB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC5C,CAAC;IACF,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;QAC3B;;WAEG;QACH,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE;KAClC,CAAC;CACH,CAAC;KACD,OAAO,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC"}

package/dist/renderers/text/index.d.ts

@@ -0,0 +1,4 @@
+export * from './render-text-template-file-action.js';
+export * from './render-text-template-group-action.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/renderers/text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/renderers/text/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,YAAY,CAAC"}

package/dist/renderers/text/index.js

@@ -0,0 +1,4 @@
+export * from './render-text-template-file-action.js';
+export * from './render-text-template-group-action.js';
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/renderers/text/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/renderers/text/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,YAAY,CAAC"}