prettier-plugin-multiline-arrays-2 1.0.0

package/dist/test/prettier-versions.mock.script.js

@@ -0,0 +1,123 @@
+import { assert, assertWrap } from "@augment-vir/assert";
+import { awaitedBlockingMap, indent, log, logColors, } from "@augment-vir/common";
+import { readPackageJson, runShellCommand } from "@augment-vir/node";
+import { calculateRelativeDate, createUtcFullDate, getNowInUtcTimezone, toTimestamp, } from "date-vir";
+import { resolve } from "node:path";
+import { assertValidShape, defineShape, recordShape, unknownShape, } from "object-shape-tester";
+import semver from "semver";
+const repoRootDirPath = resolve(import.meta.dirname, "..", "..");
+const repoPackageJson = await readPackageJson(repoRootDirPath);
+const supportedPrettierRange = assertWrap.isTruthy(repoPackageJson.peerDependencies?.prettier, "Failed to find supported Prettier version range from peer dependencies.");
+const currentPrettierVersion = assertWrap.isTruthy(repoPackageJson.devDependencies?.prettier, "Failed to find current Prettier version from dev dependencies.");
+async function fetchPrettierV3MinorVersions() {
+    const response = await fetch("https://registry.npmjs.org/prettier");
+    if (!response.ok) {
+        throw new Error(`Failed to fetch npm metadata: ${response.status}`);
+    }
+    const responseJson = await response.json();
+    assertValidShape(responseJson, defineShape({
+        versions: recordShape({
+            keys: "",
+            values: unknownShape(),
+        }),
+        time: recordShape({
+            keys: "",
+            values: "",
+        }),
+    }), {
+        allowExtraKeys: true,
+    });
+    const oldestAllowedPublishTime = toTimestamp(calculateRelativeDate(getNowInUtcTimezone(), {
+        days: -5,
+    }));
+    const rawVersions = Object.keys(responseJson.versions).filter((version) => {
+        const publishTime = responseJson.time[version];
+        if (!publishTime) {
+            log.warning(`Failed to find publish time for Prettier version: ${version}`);
+            return false;
+        }
+        return (toTimestamp(createUtcFullDate(publishTime)) <=
+            oldestAllowedPublishTime);
+    });
+    const mappedLatestMinorVersions = rawVersions.reduce((latestMinorVersions, version) => {
+        if (!semver.satisfies(version, supportedPrettierRange)) {
+            return latestMinorVersions;
+        }
+        const parsedVersion = semver.parse(version);
+        if (!parsedVersion) {
+            log.warning(`Failed to parse Prettier version with semver: ${version}`);
+            return latestMinorVersions;
+        }
+        const key = `${parsedVersion.major}.${parsedVersion.minor}`;
+        const previousVersion = latestMinorVersions[key];
+        if (!previousVersion || semver.gt(version, previousVersion)) {
+            latestMinorVersions[key] = version;
+        }
+        return latestMinorVersions;
+    }, {});
+    return Object.values(mappedLatestMinorVersions).sort(semver.compare);
+}
+async function runPrettierTests() {
+    const prettierVersions = await fetchPrettierV3MinorVersions();
+    log.info(`Testing with prettier versions:\n${indent(prettierVersions.join("\n"))}`);
+    const versionPasses = await awaitedBlockingMap(prettierVersions, async (version) => {
+        log.info(`\n\n>>>>>>>>>> Prettier v${version}\n`);
+        try {
+            log.faint(`Installing Prettier v${version}...`);
+            await runShellCommand(`npm i -D --no-save prettier@${version}`, {
+                cwd: repoRootDirPath,
+                rejectOnError: true,
+            });
+            const { stdout } = await runShellCommand("npm ls prettier", {
+                cwd: repoRootDirPath,
+            });
+            assert.hasValue(stdout, `└── prettier@${version}`, `Prettier v${version} was not installed.`);
+        }
+        catch (error) {
+            log.faint(error);
+            log.error(`Failed to install Prettier v${version}.`);
+            return {
+                version,
+                success: false,
+            };
+        }
+        log.faint(`Running tests for Prettier v${version}...`);
+        try {
+            await runShellCommand("npm test", {
+                cwd: repoRootDirPath,
+                rejectOnError: true,
+                hookUpToConsole: true,
+            });
+            return {
+                version,
+                success: true,
+            };
+        }
+        catch {
+            return {
+                version,
+                success: false,
+            };
+        }
+    });
+    log.faint(`Restoring Prettier v${currentPrettierVersion}...\n\n`);
+    await runShellCommand(`npm i -D --no-save prettier@${currentPrettierVersion}`, {
+        cwd: repoRootDirPath,
+        rejectOnError: true,
+    });
+    versionPasses.forEach(({ success, version }) => {
+        log.info(`Prettier v${version}: ${success ? logColors.success : logColors.error}${success ? "pass" : "fail"}${logColors.reset}`);
+    });
+    const success = versionPasses.every(({ success }) => {
+        return success;
+    });
+    if (success) {
+        log.success("Versioned tests passed.");
+        process.exit(0);
+    }
+    else {
+        log.error("Versioned tests failed.");
+        process.exit(1);
+    }
+}
+await runPrettierTests();

package/dist/test/run-tests.mock.d.ts

@@ -0,0 +1,17 @@
+import { type PartialWithNullable } from '@augment-vir/common';
+import { type Options as PrettierOptions } from 'prettier';
+import { type MultilineArrayOptions } from '../options.js';
+export type MultilineArrayTest = {
+    it: string;
+    code: string;
+    expect?: string | undefined;
+    options?: (Partial<MultilineArrayOptions> & PartialWithNullable<PrettierOptions>) | undefined;
+    only?: true;
+    skip?: true;
+    failureMessage?: string;
+};
+export declare function runTests({ extension, tests, parser, }: Readonly<{
+    extension: string;
+    tests: MultilineArrayTest[];
+    parser: string;
+}>): void;

package/dist/test/run-tests.mock.js

@@ -0,0 +1,95 @@
+import { assert, check } from '@augment-vir/assert';
+import { omitObjectKeys, removeColor, removeNullishValues, } from '@augment-vir/common';
+import { it } from '@augment-vir/test';
+import { format as prettierFormat } from 'prettier';
+import { repoConfig } from './prettier-config.js';
+async function runPrettierFormat({ code, extension, options = {}, parser, }) {
+    if (extension.startsWith('.')) {
+        extension = extension.slice(1);
+    }
+    const filepathOptions = check.isString(options.filepath)
+        ? {
+            filepath: options.filepath,
+        }
+        : 'filepath' in options
+            ? {}
+            : {
+                filepath: `blah.${extension}`,
+            };
+    const prettierOptions = {
+        ...repoConfig,
+        ...removeNullishValues(omitObjectKeys(options, [
+            'filepath',
+        ])),
+        ...filepathOptions,
+        ...(parser
+            ? {
+                parser,
+            }
+            : {}),
+    };
+    return await prettierFormat(code, prettierOptions);
+}
+let forced = false;
+let allPassed = true;
+function removeIndent(input) {
+    return (input
+        .replace(/^\s*\n\s*/, '')
+        .replace(/\n {12}/g, '\n')
+        // this is only used for tests
+        .replace(/\n[ \t]+$/, '\n'));
+}
+export function runTests({ extension, tests, parser, }) {
+    tests.forEach((test) => {
+        async function testCallback() {
+            try {
+                const inputCode = removeIndent(test.code);
+                const expected = removeIndent(test.expect ?? test.code);
+                const formatted = await runPrettierFormat({
+                    code: inputCode,
+                    extension,
+                    options: test.options,
+                    parser,
+                });
+                assert.strictEquals(formatted, expected);
+                if (formatted !== expected) {
+                    allPassed = false;
+                }
+            }
+            catch (error) {
+                allPassed = false;
+                if (test.failureMessage && error instanceof Error) {
+                    const strippedMessage = removeColor(error.message);
+                    if (test.failureMessage !== strippedMessage) {
+                        console.info({
+                            strippedMessage,
+                        });
+                    }
+                    assert.strictEquals(removeColor(strippedMessage), test.failureMessage);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        if (test.only) {
+            forced = true;
+            // eslint-disable-next-line sonarjs/no-exclusive-tests
+            it.only(test.it, testCallback);
+        }
+        else if (test.skip) {
+            it.skip(test.it, testCallback);
+        }
+        else {
+            it(test.it, testCallback);
+        }
+    });
+    if (forced) {
+        // eslint-disable-next-line sonarjs/no-exclusive-tests
+        it.only('forced tests should not remain in the code', () => {
+            if (allPassed) {
+                assert.strictEquals(forced, false, 'Only tests are not allowed.');
+            }
+        });
+    }
+}

package/dist/test/typescript-tests.mock.d.ts

@@ -0,0 +1,2 @@
+import { type MultilineArrayTest } from './run-tests.mock.js';
+export declare const typescriptTests: MultilineArrayTest[];