@atls/code-schematics 1.0.0 → 2.0.1

package/dist/getters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './stream-report-options.getter.js';
+export * from './stream-report-callback.getter.js';

package/dist/getters/index.js

@@ -0,0 +1,2 @@
+export * from "./stream-report-options.getter.js";
+export * from "./stream-report-callback.getter.js";

package/dist/getters/stream-report-callback.getter.d.ts

@@ -0,0 +1,4 @@
+import type { StreamReport } from '@yarnpkg/core';
+type StreamReportCallbackType = Parameters<typeof StreamReport.start>[1];
+export declare const getStreamReportCallback: (options: Record<string, string>) => Promise<StreamReportCallbackType>;
+export {};

package/dist/getters/stream-report-callback.getter.js

@@ -0,0 +1,20 @@
+import { ppath } from '@yarnpkg/fslib';
+import { xfs } from '@yarnpkg/fslib';
+import { runSchematicHelper } from '../helpers/index.js';
+import { writeTmpSchematicHelper } from '../helpers/index.js';
+import { prepareTmpDir } from '../helpers/index.js';
+export const getStreamReportCallback = async (options) => {
+    const streamReportCallback = async (report) => {
+        try {
+            const tmpDir = await xfs.mktempPromise();
+            const collectionPath = ppath.join(tmpDir, 'collection.json');
+            await writeTmpSchematicHelper(tmpDir);
+            await prepareTmpDir(tmpDir);
+            await runSchematicHelper('project', options, collectionPath);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    };
+    return streamReportCallback;
+};

package/dist/getters/stream-report-options.getter.d.ts

@@ -0,0 +1,6 @@
+import type { BaseCommand } from '@yarnpkg/cli';
+import type { Configuration } from '@yarnpkg/core';
+import type { StreamReport } from '@yarnpkg/core';
+type StreamReportOptionsType = Parameters<typeof StreamReport.start>[0];
+export declare const getStreamReportOptions: (command: BaseCommand, configuration: Configuration) => StreamReportOptionsType;
+export {};

package/dist/getters/stream-report-options.getter.js

@@ -0,0 +1,7 @@
+export const getStreamReportOptions = (command, configuration) => {
+    const streamReportOptions = {
+        stdout: command.context.stdout,
+        configuration,
+    };
+    return streamReportOptions;
+};

package/dist/helpers/events-log.helper.d.ts

@@ -0,0 +1,2 @@
+import type { DryRunEvent } from '@angular-devkit/schematics';
+export declare const eventsLogHelper: (event: DryRunEvent) => void;

package/dist/helpers/events-log.helper.js

@@ -0,0 +1,20 @@
+export const eventsLogHelper = (event) => {
+    const eventPath = event.path;
+    switch (event.kind) {
+        case 'error':
+            console.error(`ERROR! ${eventPath} ${event.description === 'alreadyExist' ? 'already exists' : 'does not exist'}.`);
+            break;
+        case 'update':
+            console.debug(`${'UPDATE'} ${eventPath} (${event.content.length} bytes)`);
+            break;
+        case 'create':
+            console.debug(`${'CREATE'} ${eventPath} (${event.content.length} bytes)`);
+            break;
+        case 'delete':
+            console.debug(`${'DELETE'} ${eventPath}`);
+            break;
+        case 'rename':
+            console.debug(`${'RENAME'} ${eventPath} => ${event.to}`);
+            break;
+    }
+};

package/dist/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './run-schematics.helper.js';
+export * from './write-tmp-schematic.helper.js';
+export * from './prepare-tmp-dir.helper.js';

package/dist/helpers/index.js

@@ -0,0 +1,3 @@
+export * from "./run-schematics.helper.js";
+export * from "./write-tmp-schematic.helper.js";
+export * from "./prepare-tmp-dir.helper.js";

package/dist/helpers/prepare-tmp-dir.helper.d.ts

@@ -0,0 +1,2 @@
+import type { PortablePath } from '@yarnpkg/fslib';
+export declare const prepareTmpDir: (tmpDir: PortablePath) => Promise<void>;

package/dist/helpers/prepare-tmp-dir.helper.js

@@ -0,0 +1,8 @@
+import { ppath } from '@yarnpkg/fslib';
+import { xfs } from '@yarnpkg/fslib';
+export const prepareTmpDir = async (tmpDir) => {
+    const projectRoot = process.cwd();
+    await xfs.copyFilePromise(ppath.join(projectRoot, '.pnp.cjs'), ppath.join(tmpDir, '.pnp.cjs'));
+    await xfs.symlinkPromise(ppath.join(projectRoot, 'package.json'), ppath.join(tmpDir, 'package.json'));
+    await xfs.symlinkPromise(ppath.join(projectRoot, 'runtime'), ppath.join(tmpDir, 'runtime'));
+};

package/dist/helpers/run-schematics.helper.d.ts

@@ -0,0 +1 @@
+export declare const runSchematicHelper: (schematicName: string, options: Record<string, string>, collectionPath: string) => Promise<0 | 1>;

package/dist/helpers/run-schematics.helper.js

@@ -0,0 +1,48 @@
+import { UnsuccessfulWorkflowExecution } from '@angular-devkit/schematics';
+import { NodeWorkflow } from '@angular-devkit/schematics/tools';
+import { eventsLogHelper } from './events-log.helper.js';
+export const runSchematicHelper = async (schematicName, options, collectionPath) => {
+    const dryRun = false;
+    const debug = true;
+    let nothingDone = true;
+    const workflow = new NodeWorkflow(process.cwd(), {
+        force: false,
+        dryRun,
+        resolvePaths: [process.cwd(), import.meta.dirname],
+        packageManager: 'yarn',
+    });
+    workflow.reporter.subscribe((event) => {
+        nothingDone = false;
+        eventsLogHelper(event);
+    });
+    try {
+        await workflow
+            .execute({
+            collection: collectionPath,
+            schematic: schematicName,
+            options,
+            allowPrivate: true,
+            debug,
+        })
+            .toPromise();
+        if (nothingDone) {
+            console.info('Nothing to be done.');
+        }
+        else if (dryRun) {
+            console.info('Dry run enabled. No files written to disk.');
+        }
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof UnsuccessfulWorkflowExecution) {
+            console.debug('The Schematic workflow failed. See above.');
+        }
+        else if (debug && err instanceof Error) {
+            console.debug(`An error occured:\n${err.stack}`);
+        }
+        else {
+            console.debug(`Error: ${err instanceof Error ? err.message : err}`);
+        }
+        return 1;
+    }
+};

package/dist/helpers/write-tmp-schematic.helper.d.ts

@@ -0,0 +1,2 @@
+import type { PortablePath } from '@yarnpkg/fslib';
+export declare const writeTmpSchematicHelper: (tmpDir: PortablePath) => Promise<void>;

package/dist/helpers/write-tmp-schematic.helper.js

@@ -0,0 +1,11 @@
+import { mkdir } from 'node:fs/promises';
+import { ppath } from '@yarnpkg/fslib';
+import { writeSchematicFactory } from '../generated/index.js';
+export const writeTmpSchematicHelper = async (tmpDir) => {
+    const { writeFiles } = await import('@atls/code-runtime');
+    await writeFiles(tmpDir);
+    const projectDir = ppath.join(tmpDir, 'project');
+    await mkdir(projectDir, { recursive: true });
+    await writeSchematicFactory(ppath.join(projectDir, 'project.factory.cjs'));
+    console.info('All Schematic files writed to the tmp!');
+};

package/dist/index.d.ts

@@ -1 +1,4 @@
-export * from './schematics.js';
+export * from './getters/index.js';
+export * from './helpers/index.js';
+export * from './generated/index.js';
+export * from './scripts/index.js';

package/dist/index.js

@@ -1 +1,4 @@
-export * from "./schematics.js";
+export * from "./getters/index.js";
+export * from "./helpers/index.js";
+export * from "./generated/index.js";
+export * from "./scripts/index.js";

package/dist/schematic/index.d.ts

@@ -0,0 +1 @@
+export * from './project/index.js';

package/dist/schematic/index.js

@@ -0,0 +1 @@
+export * from "./project/index.js";

package/dist/schematic/project/index.d.ts

@@ -0,0 +1 @@
+export * from './project.factory.js';

package/dist/schematic/project/index.js

@@ -0,0 +1 @@
+export * from "./project.factory.js";

package/dist/schematic/project/project.factory.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from '@angular-devkit/schematics';
+export declare const main: (options: Record<string, string>) => Rule;

package/dist/schematic/project/project.factory.js

@@ -0,0 +1,11 @@
+import { MergeStrategy } from '@angular-devkit/schematics';
+import { chain } from '@angular-devkit/schematics';
+import { mergeWith } from '@angular-devkit/schematics';
+import { updateTsConfigRule } from '../rules/index.js';
+import { generateCommonSource } from '../sources/index.js';
+import { generateProjectSpecificSource } from '../sources/index.js';
+export const main = (options) => chain([
+    updateTsConfigRule,
+    mergeWith(generateCommonSource(options), MergeStrategy.Overwrite),
+    mergeWith(generateProjectSpecificSource(options), MergeStrategy.Overwrite),
+]);

package/dist/schematic/rules/index.d.ts

@@ -0,0 +1 @@
+export * from './update-ts-config.rule.js';

package/dist/schematic/rules/index.js

@@ -0,0 +1 @@
+export * from "./update-ts-config.rule.js";

package/dist/schematic/rules/update-ts-config.rule.d.ts

@@ -0,0 +1,2 @@
+import { updateTsConfigInTree } from '../utils/tsconfig.utils.js';
+export declare const updateTsConfigRule: () => Promise<ReturnType<typeof updateTsConfigInTree>>;

package/dist/schematic/rules/update-ts-config.rule.js

@@ -0,0 +1,7 @@
+import { updateTsConfigInTree } from '../utils/tsconfig.utils.js';
+export const updateTsConfigRule = async () => {
+    const { tsConfig } = await import('@atls/code-runtime');
+    return updateTsConfigInTree({
+        ...tsConfig.compilerOptions,
+    });
+};

package/dist/schematic/sources/generate-common.source.d.ts

@@ -0,0 +1,2 @@
+import type { Source } from '@angular-devkit/schematics';
+export declare const generateCommonSource: (options: Record<string, string>) => Source;

package/dist/schematic/sources/generate-common.source.js

@@ -0,0 +1,13 @@
+import { strings } from '@angular-devkit/core';
+import { apply } from '@angular-devkit/schematics';
+import { template } from '@angular-devkit/schematics';
+import { move } from '@angular-devkit/schematics';
+import { url } from '@angular-devkit/schematics';
+export const generateCommonSource = (options) => apply(url('../templates/common'), [
+    template({
+        ...strings,
+        ...options,
+        dot: '.',
+    }),
+    move('./'),
+]);

package/dist/schematic/sources/generate-project-specific.source.d.ts

@@ -0,0 +1,2 @@
+import type { Source } from '@angular-devkit/schematics';
+export declare const generateProjectSpecificSource: (options: Record<string, string>) => Source;

package/dist/schematic/sources/generate-project-specific.source.js

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { strings } from '@angular-devkit/core';
+import { apply } from '@angular-devkit/schematics';
+import { url } from '@angular-devkit/schematics';
+import { template } from '@angular-devkit/schematics';
+import { move } from '@angular-devkit/schematics';
+export const generateProjectSpecificSource = (options) => {
+    const { name: projectName } = JSON.parse(readFileSync(join(options.cwd, 'package.json'), 'utf-8'));
+    return apply(url(join('../templates', options.type)), [
+        template({
+            ...strings,
+            ...options,
+            projectName,
+            dot: '.',
+        }),
+        move('./'),
+    ]);
+};

package/dist/schematic/sources/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generate-common.source.js';
+export * from './generate-project-specific.source.js';

package/dist/schematic/sources/index.js

@@ -0,0 +1,2 @@
+export * from "./generate-common.source.js";
+export * from "./generate-project-specific.source.js";

package/dist/schematic/utils/file.utils.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '@angular-devkit/schematics';
+import type { SchematicContext } from '@angular-devkit/schematics';
+export declare const updateFileInTree: (path: string, callback: (file: string, context: SchematicContext) => string) => Rule;

package/dist/schematic/utils/file.utils.js

@@ -0,0 +1,6 @@
+export const updateFileInTree = (path, callback) => (host, context) => {
+    if (host.exists(path)) {
+        host.overwrite(path, callback(host.read(path).toString('utf-8'), context));
+    }
+    return host;
+};

package/dist/schematic/utils/gitignore.utils.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '@angular-devkit/schematics';
+import type { SchematicContext } from '@angular-devkit/schematics';
+export declare const updateGitIgnoreInTree: (callback: (lines: Array<string>, context: SchematicContext) => Array<string>) => Rule;

package/dist/schematic/utils/gitignore.utils.js

@@ -0,0 +1,12 @@
+const GITIGNORE_PATH = '.gitignore';
+export const updateGitIgnoreInTree = (callback) => (host, context) => {
+    if (!host.exists(GITIGNORE_PATH)) {
+        host.create(GITIGNORE_PATH, '');
+    }
+    const gitignoreBuffer = host.read(GITIGNORE_PATH);
+    if (!gitignoreBuffer)
+        return host;
+    const content = gitignoreBuffer.toString('utf-8').split('\n');
+    host.overwrite(GITIGNORE_PATH, Array.from(callback(content, context)).join('\n'));
+    return host;
+};

package/dist/schematic/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './gitignore.utils.js';
+export * from './tsconfig.utils.js';
+export * from './json.utils.js';
+export * from './yaml.utils.js';
+export * from './file.utils.js';

package/dist/schematic/utils/index.js

@@ -0,0 +1,5 @@
+export * from "./gitignore.utils.js";
+export * from "./tsconfig.utils.js";
+export * from "./json.utils.js";
+export * from "./yaml.utils.js";
+export * from "./file.utils.js";

package/dist/schematic/utils/json.utils.d.ts

@@ -0,0 +1,6 @@
+import type { Rule } from '@angular-devkit/schematics';
+import type { SchematicContext } from '@angular-devkit/schematics';
+import type { Tree } from '@angular-devkit/schematics';
+export declare const serializeJson: (json: string) => string;
+export declare const readJsonInTree: (host: Tree, path: string) => void;
+export declare const updateJsonInTree: <T = any, O = T>(path: string, callback: (json: T, context: SchematicContext) => O) => Rule;

package/dist/schematic/utils/json.utils.js

@@ -0,0 +1,23 @@
+import stripJsonComments from 'strip-json-comments';
+export const serializeJson = (json) => `${JSON.stringify(json, null, 2)}\n`;
+export const readJsonInTree = (host, path) => {
+    if (!host.exists(path)) {
+        throw new Error(`Cannot find ${path}`);
+    }
+    const contents = stripJsonComments(host.read(path)?.toString('utf-8') || '');
+    try {
+        return JSON.parse(contents);
+    }
+    catch (e) {
+        const error = e;
+        throw new Error(`Cannot parse ${path}: ${error.message}`);
+    }
+};
+export const updateJsonInTree = (path, callback) => (host, context) => {
+    if (!host.exists(path)) {
+        host.create(path, serializeJson(callback({}, context)));
+        return host;
+    }
+    host.overwrite(path, serializeJson(callback(readJsonInTree(host, path), context)));
+    return host;
+};

package/dist/schematic/utils/tsconfig.utils.d.ts

@@ -0,0 +1 @@
+export declare const updateTsConfigInTree: (compilerOptions: object) => import("@angular-devkit/schematics").Rule;

package/dist/schematic/utils/tsconfig.utils.js

@@ -0,0 +1,5 @@
+import { updateJsonInTree } from './json.utils.js';
+export const updateTsConfigInTree = (compilerOptions) => updateJsonInTree('tsconfig.json', (tsconfig) => ({
+    ...tsconfig,
+    compilerOptions,
+}));

package/dist/schematic/utils/yaml.utils.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from '@angular-devkit/schematics';
+import type { SchematicContext } from '@angular-devkit/schematics';
+import type { Tree } from '@angular-devkit/schematics';
+export declare const readYamlInTree: <T = any>(host: Tree, path: string) => T;
+export declare const updateYamlInTree: <T = any, O = T>(path: string, callback: (yaml: T, context: SchematicContext) => O) => Rule;

package/dist/schematic/utils/yaml.utils.js

@@ -0,0 +1,18 @@
+import { load } from 'js-yaml';
+import { dump } from 'js-yaml';
+export const readYamlInTree = (host, path) => {
+    if (!host.exists(path)) {
+        throw new Error(`Cannot find ${path}`);
+    }
+    return load(host.read(path).toString('utf-8'));
+};
+export const updateYamlInTree = (path, callback) => (host, context) => {
+    if (!host.exists(path)) {
+        return host;
+    }
+    host.overwrite(path, dump(callback(readYamlInTree(host, path), context), {
+        noArrayIndent: true,
+        lineWidth: -1,
+    }));
+    return host;
+};

package/dist/scripts/build-steps/esbuild.build-step.d.ts

@@ -0,0 +1 @@
+export declare const esbuildBuildStep: () => Promise<void>;

package/dist/scripts/build-steps/esbuild.build-step.js

@@ -0,0 +1,17 @@
+import { writeFile } from 'fs/promises';
+import esbuild from 'esbuild';
+import { UndefinedBuildRedultException } from '../exceptions/index.js';
+import { getEsbuildConfig } from '../getters/index.js';
+import { getCjsContent } from '../getters/index.js';
+import { getEncodedContent } from '../getters/index.js';
+import { getGeneratedFileContent } from '../getters/index.js';
+export const esbuildBuildStep = async () => {
+    const esbuildConfig = getEsbuildConfig();
+    const result = await esbuild.build(esbuildConfig);
+    if (!result.outputFiles)
+        throw new UndefinedBuildRedultException();
+    const cjsContent = getCjsContent(result);
+    const encodedContent = getEncodedContent(cjsContent);
+    const generatedFileContent = getGeneratedFileContent(encodedContent);
+    await writeFile('src/generated/schematic-factory-export.ts', generatedFileContent);
+};

package/dist/scripts/build-steps/index.d.ts

@@ -0,0 +1 @@
+export * from './esbuild.build-step.js';

package/dist/scripts/build-steps/index.js

@@ -0,0 +1 @@
+export * from "./esbuild.build-step.js";

package/dist/scripts/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from './undefined-build-result.exception.js';

package/dist/scripts/exceptions/index.js

@@ -0,0 +1 @@
+export * from "./undefined-build-result.exception.js";

package/dist/scripts/exceptions/undefined-build-result.exception.d.ts

@@ -0,0 +1,3 @@
+export declare class UndefinedBuildRedultException extends Error {
+    constructor();
+}

package/dist/scripts/exceptions/undefined-build-result.exception.js

@@ -0,0 +1,5 @@
+export class UndefinedBuildRedultException extends Error {
+    constructor() {
+        super('SchematicFactory build result is undefined');
+    }
+}

package/dist/scripts/getters/cjs-content.getter.d.ts

@@ -0,0 +1,2 @@
+import type { BuildResult } from 'esbuild';
+export declare const getCjsContent: (buildResult: BuildResult) => string;

package/dist/scripts/getters/cjs-content.getter.js

@@ -0,0 +1,4 @@
+export const getCjsContent = (buildResult) => {
+    const cjsContent = buildResult.outputFiles[0].text;
+    return cjsContent;
+};

package/dist/scripts/getters/encoded-content.getter.d.ts

@@ -0,0 +1 @@
+export declare const getEncodedContent: (cjsContent: string) => string;

package/dist/scripts/getters/encoded-content.getter.js

@@ -0,0 +1,4 @@
+export const getEncodedContent = (cjsContent) => {
+    const encodedContent = Buffer.from(cjsContent).toString('base64');
+    return encodedContent;
+};

package/dist/scripts/getters/esbuild-config.getter.d.ts

@@ -0,0 +1,2 @@
+import type { BuildOptions } from 'esbuild';
+export declare const getEsbuildConfig: () => BuildOptions;

package/dist/scripts/getters/esbuild-config.getter.js

@@ -0,0 +1,32 @@
+import { resolve } from 'node:path';
+import { pnpPlugin } from '@yarnpkg/esbuild-plugin-pnp';
+export const getEsbuildConfig = () => {
+    const esbuildConfig = {
+        logLevel: 'error',
+        entryPoints: ['src/schematic/index.ts'],
+        bundle: true,
+        write: false,
+        format: 'cjs',
+        platform: 'node',
+        sourcemap: false,
+        target: 'esnext',
+        external: ['node:*', '@atls/code-runtime'],
+        plugins: [
+            pnpPlugin({
+                onResolve: async (args) => {
+                    if (args.path.includes('.ts')) {
+                        return {
+                            path: resolve(args.resolveDir, args.path.replace(/\.js/, '')),
+                            external: false,
+                        };
+                    }
+                    return {
+                        namespace: args.path,
+                        external: false,
+                    };
+                },
+            }),
+        ],
+    };
+    return esbuildConfig;
+};

package/dist/scripts/getters/generated-file-content.getter.d.ts

@@ -0,0 +1 @@
+export declare const getGeneratedFileContent: (encodedContent: string) => string;

package/dist/scripts/getters/generated-file-content.getter.js

@@ -0,0 +1,16 @@
+const WRITE_SCHEMATIC_FACTORY_FUNCTION = `export const writeSchematicFactory = async (path: string) => {
+  const content = Buffer.from(schematicFactoryCjsBase64, "base64").toString("utf-8");
+  const fs = await import('fs/promises')
+  await fs.writeFile(path, content);
+};
+`;
+export const getGeneratedFileContent = (encodedContent) => {
+    const generatedFileContent = `// Auto-generated file
+/* eslint-disable */
+
+export const schematicFactoryCjsBase64 = "${encodedContent}";
+
+${WRITE_SCHEMATIC_FACTORY_FUNCTION}
+`;
+    return generatedFileContent;
+};

package/dist/scripts/getters/index.d.ts

@@ -0,0 +1,4 @@
+export * from './esbuild-config.getter.js';
+export * from './cjs-content.getter.js';
+export * from './encoded-content.getter.js';
+export * from './generated-file-content.getter.js';

package/dist/scripts/getters/index.js

@@ -0,0 +1,4 @@
+export * from "./esbuild-config.getter.js";
+export * from "./cjs-content.getter.js";
+export * from "./encoded-content.getter.js";
+export * from "./generated-file-content.getter.js";

package/dist/scripts/index.d.ts

@@ -0,0 +1 @@
+export * from './schematic-build.script.js';

package/dist/scripts/index.js

@@ -0,0 +1 @@
+export * from "./schematic-build.script.js";

package/dist/scripts/schematic-build.script.d.ts

@@ -0,0 +1 @@
+export declare function generateSchematic(schematicDir: string, outputFile: string): Promise<void>;

package/dist/scripts/schematic-build.script.js

@@ -0,0 +1,72 @@
+import { readdir } from 'fs/promises';
+import { mkdir } from 'fs/promises';
+import { writeFile } from 'fs/promises';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { dirname } from 'path';
+async function buildFileStructure(dirPath) {
+    const result = {};
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            result[entry.name] = await buildFileStructure(fullPath);
+        }
+        else {
+            const content = await readFile(fullPath, 'utf-8');
+            result[entry.name] = Buffer.from(content).toString('base64');
+        }
+    }
+    return result;
+}
+function generateModuleContent(structure) {
+    const createStructureCode = (obj, indent = '') => {
+        let code = '';
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'string') {
+                code += `${indent}'${key}': '${value}',\n`;
+            }
+            else {
+                code += `${indent}'${key}': {\n`;
+                code += createStructureCode(value, `${indent}  `);
+                code += `${indent}},\n`;
+            }
+        }
+        return code;
+    };
+    return `// Auto-generated file
+/* eslint-disable */
+export const assetsStructure = {
+${createStructureCode(structure, '  ')}
+}
+
+export async function writeFiles(baseDir: string) {
+  const { join } = await import('path')
+  const { mkdir, writeFile } = await import('fs/promises')
+
+  async function writeRecursive(obj: any, currentPath: string) {
+    for (const [key, value] of Object.entries(obj)) {
+      const fullPath = join(currentPath, key)
+
+      if (typeof value === 'string') {
+        await writeFile(
+          fullPath, 
+          Buffer.from(value, 'base64').toString('utf-8')
+        )
+      } else {
+        await mkdir(fullPath, { recursive: true })
+        await writeRecursive(value, fullPath)
+      }
+    }
+  }
+
+  await writeRecursive(assetsStructure, baseDir)
+}
+`;
+}
+export async function generateSchematic(schematicDir, outputFile) {
+    const structure = await buildFileStructure(schematicDir);
+    const moduleContent = generateModuleContent(structure);
+    await mkdir(dirname(outputFile), { recursive: true });
+    await writeFile(outputFile, moduleContent);
+}

package/dist/scripts/schematic-factory-build.script.d.ts

@@ -0,0 +1 @@
+export {};