@postxl/generator 0.74.2 → 1.0.3

package/dist/utils/prettier.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = format;
+const path_1 = require("path");
+const prettier = __importStar(require("prettier"));
+const prettier_config_1 = require("./prettier-config");
+const parsers = {
+    '.js': 'babel',
+    '.jsx': 'babel',
+    '.mjs': 'babel',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.json': 'json',
+    '.md': 'markdown',
+    '.mdx': 'mdx',
+    '.html': 'html',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.css': 'css',
+};
+async function format({ path, content }) {
+    const ext = (0, path_1.extname)(path);
+    const parser = parsers[ext];
+    if (parser === undefined || typeof content !== 'string') {
+        return content;
+    }
+    try {
+        return await prettier.format(content, { ...prettier_config_1.prettierConfig, parser });
+    }
+    catch (err) {
+        console.error(`${content}\n\nFailed to format ${path}\n\n`);
+        throw err;
+    }
+}

package/dist/utils/prettier.skiptest.d.ts

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

package/dist/utils/prettier.skiptest.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const prettier_1 = require("./prettier");
+// This test currently runs into configuration issues with Jest and Prettier.
+// According to https://github.com/prettier/prettier/issues/15769 this should be fixed in Jest v30,
+// so we will revisit this then. Until then, we disable the test (by renaming the file).
+globals_1.describe.skip('prettier', () => {
+    (0, globals_1.test)('should format TypeScript code', async () => {
+        const content = `
+    const fn = async <T>(data: unknown): T => {
+      return data as T
+    }`;
+        const result = await (0, prettier_1.format)({ path: 'test.ts', content });
+        (0, globals_1.expect)(result).toMatchInlineSnapshot(`
+"const fn = async <T,>(data: unknown): T => {
+return data as T
+}
+"
+`);
+    });
+});

package/dist/utils/promise.d.ts

@@ -0,0 +1,2 @@
+import { Typescript } from './string-functions';
+export declare function promises(tasks: (string | Typescript)[]): Typescript;

package/dist/utils/promise.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promises = promises;
+const string_functions_1 = require("./string-functions");
+function promises(tasks) {
+    if (tasks.length === 0) {
+        return (0, string_functions_1.ts)('Promise.resolve([]) // NOSONAR - to comply with async interface');
+    }
+    return (0, string_functions_1.ts)(`Promise.all([\n  ${tasks.join(',\n')}]) // NOSONAR`);
+}

package/dist/utils/string-functions.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const zTypescript: z.ZodBranded<z.ZodString, "PXL.Typescript">;
+export type Typescript = z.infer<typeof zTypescript>;
+export declare function ts(input: string): string & z.BRAND<"PXL.Typescript">;
+export declare function trimLines(input: string): string;
+/**
+ * Removes leading and trailing newlines from the input string.
+ */
+export declare function trimNewlines(input: string): string;

package/dist/utils/string-functions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zTypescript = void 0;
+exports.ts = ts;
+exports.trimLines = trimLines;
+exports.trimNewlines = trimNewlines;
+const zod_1 = require("zod");
+exports.zTypescript = zod_1.z.string().brand('PXL.Typescript');
+function ts(input) {
+    return exports.zTypescript.parse(input);
+}
+function trimLines(input) {
+    return input
+        .split('\n')
+        .map((l) => l.trim())
+        .join('\n');
+}
+/**
+ * Removes leading and trailing newlines from the input string.
+ */
+function trimNewlines(input) {
+    return input.replace(/^\n+/g, '').replace(/\n+$/g, ''); //NOSONAR - regex is only run on code generation, not dependant on user input
+}

package/dist/utils/sync-log-result.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from './logger.class';
+import { SyncResults } from './sync';
+type LogResultsOptions = {
+    showEjectedStats?: boolean;
+    showEjectedDiff?: boolean;
+    logger?: Logger;
+};
+export declare function logSyncResult(results: SyncResults, options?: LogResultsOptions): void;
+export {};

package/dist/utils/sync-log-result.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logSyncResult = logSyncResult;
+const utils_1 = require("@postxl/utils");
+const logger_class_1 = require("./logger.class");
+const merge_conflict_1 = require("./merge-conflict");
+function logSyncResult(results, options = {}) {
+    const logger = options.logger ?? new logger_class_1.Logger();
+    // Handle failed sync due to unresolved merge conflicts
+    if (!results.success) {
+        logger.log((0, utils_1.bold)((0, utils_1.red)('❌ Generation aborted: Unresolved merge conflicts detected')));
+        logger.log((0, utils_1.red)(results.error.message));
+        logger.log('');
+        logger.log((0, utils_1.bold)((0, utils_1.red)(`Files with unresolved merge conflicts (${results.error.filesWithConflicts.length}):`)));
+        for (const file of results.error.filesWithConflicts) {
+            logger.log((0, utils_1.red)(` └── ${file}`));
+        }
+        logger.log('');
+        logger.log((0, utils_1.yellow)('Please resolve these conflicts before running the generator again.'));
+        return;
+    }
+    const actionGroups = {
+        Delete: [],
+        MergeConflict: [],
+        Write: [],
+        NoAction: [],
+        Ejected: [],
+    };
+    for (const [path, result] of Object.entries(results.files)) {
+        actionGroups[result.action.type].push(path);
+        if (result.isEjected) {
+            actionGroups['Ejected'].push(path);
+        }
+    }
+    logActionResult('Delete', actionGroups['Delete'], utils_1.red, 'deleted', logger);
+    logActionResult('MergeConflict', actionGroups['MergeConflict'], utils_1.yellow, 'with merge conflicts', logger);
+    logActionResult('Write', actionGroups['Write'], utils_1.green, 'written:', logger);
+    logActionResult('NoAction', actionGroups['NoAction'], utils_1.cyan, 'unchanged', logger);
+    if (options.showEjectedStats) {
+        if (actionGroups['Ejected'].length === 0) {
+            logger.log('✅ No files ejected');
+        }
+        else {
+            logActionResult('Ejected', actionGroups['Ejected'], utils_1.red, 'ejected:', logger);
+        }
+    }
+    if (options.showEjectedDiff) {
+        logEjectedDiff({
+            ejectedFiles: actionGroups['Ejected'],
+            showEjectedStats: options.showEjectedStats ?? false,
+            files: results.files,
+            logger,
+        });
+    }
+    if (results.errors.length > 0) {
+        logger.log((0, utils_1.bold)((0, utils_1.red)('Errors:')));
+        for (const error of results.errors) {
+            logger.log((0, utils_1.red)(error.message));
+        }
+    }
+}
+function logActionResult(action, paths, color, stateDescription, logger) {
+    if (paths.length === 0) {
+        return;
+    }
+    const fileLabel = paths.length === 1 ? 'file' : 'files';
+    logger.log((0, utils_1.bold)(color(`${paths.length} ${fileLabel} ${stateDescription}`)));
+    if (action === 'NoAction') {
+        return;
+    }
+    paths.forEach((path) => {
+        logger.log((0, utils_1.gray)(` └── ${path}`));
+    });
+}
+function logEjectedDiff({ ejectedFiles, showEjectedStats, files, logger, }) {
+    if (ejectedFiles.length === 0) {
+        if (!showEjectedStats) {
+            logger.log('✅ No files ejected');
+        }
+    }
+    else {
+        for (const path of ejectedFiles) {
+            logger.log((0, utils_1.bold)((0, utils_1.red)(`Ejected ${path}`)));
+            const inputState = files[path].inputState;
+            const contentSource = inputState.disk.state === 'hash' ? inputState.disk.content : '';
+            const contentIncoming = inputState.virtual.state === 'hash' ? inputState.virtual.content : '';
+            logger.log((0, merge_conflict_1.generateDiffSummary)({ contentSource, contentIncoming }));
+        }
+    }
+}

package/dist/utils/sync.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The virtual file system represents a file system that can be manipulated in memory.
+ *
+ * This sync extension allows a 3-way sync between the file system and the disk.
+ *
+ * The 3 sources are:
+ * 1. The data written by code/the generators to the VFS
+ * 2. The hash sums from prior generations (indicating which files were changed)
+ * 3. The actual disk files
+ *
+ * The overall usage pattern is:
+ * 1. The VFS initializes with a lock file - and reads the hash sums from the disk
+ * 2. The code/generators write to the VFS
+ * 3. The VFS "writes" to disk, performing this 3-way sync with the below algorithm
+ *
+ *
+ * ### Algorithm
+ *
+ * For each file in the VFS we have 3 different states - the file in memory (`virtual`), the hash sum from prior generations from the lock file (`lock`), and the file from disk (`disk`).
+ *
+ * Each of these 3 states can be "empty" - in case the file was not generated/generated last time/does not exist on disk - or represented by a hash value (`H`).
+ *
+ * Thus, we have the following potential states for each file:
+ * - virtual: `empty` | `Hash1` (hash sum from current generation)
+ * - lock:    `empty` | `Hash1` | `Hash0` (hash sum from prior generation)
+ * - disk:    `empty` | `Hash1` | `Hash0` | `HashX` (different hash sum from disk)
+ *
+ * The below table shows all possible combinations of these states - and the resulting action that needs to be performed:
+ *
+ * |-------|-------|---------|---------------------------------|---------------------------|
+ * | VFS   | Lock  | Disk    | Description                     | Action on disk            |
+ * |-------|-------|---------|---------------------------------|---------------------------|
+ * | Hash1 | Hash1 | Hash1   | Unchanged                       | No action                 |
+ * | Hash1 | Hash1 | HashX/0 | Ejected                         | No action                 |
+ * | Hash1 | Hash1 | empty   | Deleted on disk                 | No action                 |
+ * | Hash1 | Hash0 | Hash1   | Corrupt lock file?              | No action                 |
+ * | Hash1 | Hash0 | Hash0   | Changed, not ejected            | Update to VFS version     |
+ * | Hash1 | Hash0 | HashX   | Changed, ejected                | Create "merge conflict"(2)|
+ * | Hash1 | Hash0 | empty   | Changed, deleted on disk        | Write file (1)            |
+ * | Hash1 | empty | Hash1   | Corrupt lock file?              | No action                 |
+ * | Hash1 | empty | HashX/0 | File ejected, corrupt lock file | Create "merge conflict"(2)|
+ * | Hash1 | empty | empty   | Newly generated                 | Write file                |
+ * |-------|-------|---------|---------------------------------|---------------------------|
+ * | empty | Hash0 | Hash0   | Unejected file                  | Delete file               |
+ * | empty | Hash0 | HashX   | Ejected file was deleted        | Delete file (3)           |
+ * | empty | Hash0 | empty   | File was manually deleted first | No action                 |
+ * | empty | empty | HashX   | Manual file                     | No action                 |
+ * | empty | empty | empty   | Cannot occur                    |                           |
+ * |-------|-------|---------|---------------------------------|---------------------------|
+ *
+ * Notes:
+ * (1) In case the file was deleted on disk and changed between the last generation and the current generation, we will write the file to disk. The developer can decide to keep the "restored" file or not. Next time generator runs, it will not be regenerated, as lock file hashes match.
+ * (2) In case the file was ejected and changed between the last generation and the current generation, we will overwrite the file on disk - with git "merge conflict" markers. The developer must then decide how to resolve the conflicts.
+ * (3) In case the file was deleted by the generator but ejected by the developer, we will delete the file from disk. The developer can decide to revert the deletion or not. Next time generator runs, it will not be regenerated, as lock file hashes match.
+ *
+ */
+import { Result, TypedError } from '@postxl/utils';
+import { type Checksum } from './checksum';
+import { FileContent, FileErrorTypes } from './fs-utils';
+import * as Path from './path';
+import { VirtualFileSystem } from './vfs.class';
+type SyncParams = {
+    vfs: VirtualFileSystem;
+    lockFilePath: string;
+    diskFilePath: string;
+    force: boolean;
+};
+/**
+ * Error returned when files with unresolved merge conflicts are detected
+ */
+export type UnresolvedMergeConflictsError = {
+    type: 'UnresolvedMergeConflictsError';
+    message: string;
+    filesWithConflicts: Path.PosixPath[];
+};
+export type SyncErrorTypes = FileErrorTypes;
+export type ActionResult = Result<void, TypedError<FileErrorTypes>>;
+export type FileSyncResult = {
+    inputState: FileStates;
+    action: Action;
+    actionResult: ActionResult;
+    isEjected: boolean;
+};
+export type FileSyncResults = Record<Path.PosixPath, FileSyncResult>;
+export type SyncResults = {
+    success: true;
+    errors: TypedError<SyncErrorTypes>[];
+    files: FileSyncResults;
+} | {
+    success: false;
+    error: UnresolvedMergeConflictsError;
+};
+/**
+ * Synchronizes the virtual file system with the disk file system.
+ *
+ * It takes into account the lock file to determine the state of each file.
+ * Depending on the state/checksum of each file in VFS, lock file and disk file system,
+ * it will perform the appropriate action (write, delete, merge conflict) to update the disk file system.
+ *
+ * It also updates the lock file with the current state of the VFS.
+ *
+ * Note: File filtering is now handled at the VFS level, so only files that were added to the VFS
+ * (respecting any file pattern filter) will be synced and tracked in the lock file.
+ *
+ * IMPORTANT: Before writing any files, this function checks if there are any files with unresolved
+ * merge conflict markers. If found, the sync will abort immediately and return an error with the
+ * list of files that need to be resolved before generation can continue.
+ */
+export declare function sync({ vfs, lockFilePath, diskFilePath, force }: SyncParams): Promise<SyncResults>;
+type FileState = {
+    state: 'empty';
+} | {
+    state: 'hash';
+    hash: Checksum;
+};
+type FileStateWithContent = {
+    state: 'empty';
+} | {
+    state: 'hash';
+    hash: Checksum;
+    content: FileContent;
+};
+type FileStates = {
+    virtual: FileStateWithContent;
+    lock: FileState;
+    disk: FileStateWithContent;
+};
+export type Action = {
+    type: `NoAction`;
+} | {
+    type: `Write`;
+    content: FileContent;
+} | Action_MergeConflict | {
+    type: `Delete`;
+};
+type Action_MergeConflict = {
+    type: `MergeConflict`;
+    diskContent: FileContent;
+    virtualContent: FileContent;
+};
+export type ActionType = Action['type'];
+export declare function executeAction(filePath: Path.PosixPath, action: Action): Promise<ActionResult>;
+export {};