syncpack 10.7.3 → 11.2.1

package/dist/guards/is-loose-semver.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isLooseSemver = void 0;
 const is_string_1 = require("tightrope/guard/is-string");
 const is_semver_1 = require("./is-semver");
+/** @deprecated */
 function isLooseSemver(version) {
     return (0, is_string_1.isString)(version) && (0, is_semver_1.isSemver)(version) && version.search(/\.x(\.|$)/) !== -1;
 }

package/dist/guards/is-semver.d.ts

@@ -1 +1,2 @@
+/** @deprecated */
 export declare function isSemver(version: unknown): boolean;

package/dist/guards/is-semver.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSemver = void 0;
 const is_string_1 = require("tightrope/guard/is-string");
+/** @deprecated */
 function isSemver(version) {
     const range = '(~|\\^|>=|>|<=|<)?';
     const ints = '[0-9]+';

package/dist/guards/is-valid-semver-range.d.ts

@@ -1,2 +1,3 @@
 import type { SemverRange } from '../config/types';
+/** @deprecated */
 export declare function isValidSemverRange(value: unknown): value is SemverRange;

package/dist/guards/is-valid-semver-range.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidSemverRange = void 0;
 const constants_1 = require("../constants");
+/** @deprecated */
 function isValidSemverRange(value) {
     return (value === constants_1.RANGE.ANY ||
         value === constants_1.RANGE.EXACT ||

package/dist/instance/create.d.ts

@@ -0,0 +1,4 @@
+import { Instance } from '.';
+import type { Strategy } from '../config/get-custom-types';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
+export declare function createInstance(strategy: Strategy.Any, name: string, packageJsonFile: PackageJsonFile, specifier: string): Instance.Any;

package/dist/instance/create.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstance = void 0;
+const npm_package_arg_1 = __importDefault(require("npm-package-arg"));
+const _1 = require(".");
+function createInstance(strategy, name, packageJsonFile, specifier) {
+    const pkgName = packageJsonFile.contents.name || 'PACKAGE_JSON_HAS_NO_NAME';
+    try {
+        const parsedSpecifier = parseSpecifier(name, specifier, packageJsonFile);
+        switch (parsedSpecifier.type) {
+            case 'file':
+            case 'directory': {
+                return new _1.Instance.FileInstance({
+                    name,
+                    packageJsonFile,
+                    parsedSpecifier,
+                    pkgName,
+                    specifier,
+                    strategy,
+                });
+            }
+            case 'remote': {
+                return new _1.Instance.UrlInstance({
+                    name,
+                    packageJsonFile,
+                    parsedSpecifier,
+                    pkgName,
+                    specifier,
+                    strategy,
+                });
+            }
+            case 'git': {
+                return 'hosted' in parsedSpecifier
+                    ? new _1.Instance.HostedGitInstance({
+                        name,
+                        packageJsonFile,
+                        parsedSpecifier: parsedSpecifier,
+                        pkgName,
+                        specifier,
+                        strategy,
+                    })
+                    : new _1.Instance.UrlInstance({
+                        name,
+                        packageJsonFile,
+                        parsedSpecifier,
+                        pkgName,
+                        specifier,
+                        strategy,
+                    });
+            }
+            case 'alias': {
+                return new _1.Instance.AliasInstance({
+                    name,
+                    packageJsonFile,
+                    parsedSpecifier,
+                    pkgName,
+                    specifier,
+                    strategy,
+                });
+            }
+            case 'version': {
+                return new _1.Instance.VersionInstance({
+                    name,
+                    packageJsonFile,
+                    parsedSpecifier: parsedSpecifier,
+                    pkgName,
+                    specifier,
+                    strategy,
+                });
+            }
+            case 'range': {
+                return new _1.Instance.RangeInstance({
+                    name,
+                    packageJsonFile,
+                    parsedSpecifier: parsedSpecifier,
+                    pkgName,
+                    specifier,
+                    strategy,
+                });
+            }
+            case 'tag': {
+                return new _1.Instance.TagInstance({
+                    name,
+                    packageJsonFile,
+                    parsedSpecifier: parsedSpecifier,
+                    pkgName,
+                    specifier,
+                    strategy,
+                });
+            }
+            case 'workspaceProtocol': {
+                return new _1.Instance.WorkspaceProtocolInstance({
+                    name,
+                    packageJsonFile,
+                    parsedSpecifier: parsedSpecifier,
+                    pkgName,
+                    specifier,
+                    strategy,
+                });
+            }
+            default: {
+                return new _1.Instance.UnsupportedInstance({
+                    name,
+                    packageJsonFile,
+                    parsedSpecifier,
+                    pkgName,
+                    specifier,
+                    strategy,
+                });
+            }
+        }
+    }
+    catch (err) {
+        return new _1.Instance.UnsupportedInstance({
+            name,
+            packageJsonFile,
+            parsedSpecifier: err,
+            pkgName,
+            specifier,
+            strategy,
+        });
+    }
+}
+exports.createInstance = createInstance;
+function parseSpecifier(name, specifier, packageJsonFile) {
+    if (specifier.startsWith('workspace:')) {
+        const parsed = npm_package_arg_1.default.resolve(name, specifier.replace('workspace:', 'file:'), packageJsonFile.dirPath);
+        return {
+            type: 'workspaceProtocol',
+            raw: parsed.raw.replace('file:', 'workspace:'),
+            name: parsed.name,
+            escapedName: parsed.escapedName,
+            scope: parsed.scope,
+            rawSpec: parsed.rawSpec.replace('file:', 'workspace:'),
+            saveSpec: parsed.saveSpec.replace('file:', 'workspace:'),
+        };
+    }
+    return npm_package_arg_1.default.resolve(name, specifier, packageJsonFile.dirPath);
+}

package/dist/instance/index.d.ts

@@ -0,0 +1,122 @@
+import * as Data from '@effect/data/Data';
+import * as Option from '@effect/data/Option';
+import type npa from 'npm-package-arg';
+import type { AliasResult, FileResult, HostedGitResult, RegistryResult, URLResult } from 'npm-package-arg';
+import type { Strategy } from '../config/get-custom-types';
+import type { PackageJsonFile } from '../get-package-json-files/package-json-file';
+import { type Delete } from '../get-version-groups/lib/delete';
+/** Extends npm/npm-package-arg to support "workspace:*" */
+export interface WorkspaceProtocolResult {
+    type: 'workspaceProtocol';
+    raw: string;
+    name: string | null;
+    escapedName: string | null;
+    scope: string | null;
+    rawSpec: string;
+    saveSpec: string;
+}
+export type NpmPackageArgResult = ReturnType<typeof npa.resolve> | WorkspaceProtocolResult;
+interface BaseInstance<T extends NpmPackageArgResult | unknown> {
+    /** the name of this dependency */
+    name: string;
+    /** The package this dependency is installed in this specific time */
+    packageJsonFile: PackageJsonFile;
+    /** @see https://github.com/npm/npm-package-arg */
+    parsedSpecifier: T;
+    /** The .name property of the package.json file of this instance */
+    pkgName: string;
+    /** The raw: semver, git, workspace: etc version value */
+    specifier: string;
+    /** locates where in the file this dependency is installed */
+    strategy: Strategy.Any;
+}
+export declare namespace Instance {
+    /**
+     * A helper to create specific classes for each of the possible
+     * `RegistryResult` types from npm/npm-package-arg. Instead of grouping them
+     * together we are being more specific
+     */
+    type SpecificRegistryResult<T extends RegistryResult['type'] | 'local'> = Omit<RegistryResult, 'type'> & {
+        type: T;
+    };
+    const FileInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "FileInstance";
+    }>;
+    /** An `Instance` whose specifier is a path to a local file or directory */
+    export class FileInstance extends FileInstance_base<BaseInstance<FileResult>> {
+        setSpecifier: typeof setSpecifier;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    const HostedGitInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "HostedGitInstance";
+    }>;
+    /** An `Instance` whose specifier is a Git URL */
+    export class HostedGitInstance extends HostedGitInstance_base<BaseInstance<HostedGitResult>> {
+        setSpecifier: typeof setSpecifier;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    const UrlInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "URLInstance";
+    }>;
+    /** An `Instance` whose specifier is a URL to a tarball */
+    export class UrlInstance extends UrlInstance_base<BaseInstance<URLResult>> {
+        setSpecifier: typeof setSpecifier;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    const AliasInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "AliasInstance";
+    }>;
+    /** An `Instance` whose specifier is eg "npm:imageoptim-cli@3.1.7" */
+    export class AliasInstance extends AliasInstance_base<BaseInstance<AliasResult>> {
+        setSpecifier(version: string | Delete): void;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    const VersionInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "VersionInstance";
+    }>;
+    /** An `Instance` whose specifier is exact semver */
+    export class VersionInstance extends VersionInstance_base<BaseInstance<SpecificRegistryResult<'version'>>> {
+        setSpecifier: typeof setSpecifier;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    const RangeInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "RangeInstance";
+    }>;
+    /** An `Instance` whose specifier is eg. "*" or "^1.2.3" */
+    export class RangeInstance extends RangeInstance_base<BaseInstance<SpecificRegistryResult<'range'>>> {
+        setSpecifier: typeof setSpecifier;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    const TagInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "TagInstance";
+    }>;
+    /** An `Instance` whose specifier is eg. "latest" or "made-up-by-some-dev" */
+    export class TagInstance extends TagInstance_base<BaseInstance<SpecificRegistryResult<'tag'>>> {
+        setSpecifier: typeof setSpecifier;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    const WorkspaceProtocolInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "WorkspaceProtocolInstance";
+    }>;
+    /** An `Instance` whose specifier is "workspace:*" */
+    export class WorkspaceProtocolInstance extends WorkspaceProtocolInstance_base<BaseInstance<WorkspaceProtocolResult>> {
+        setSpecifier: typeof setSpecifier;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    const UnsupportedInstance_base: new <A extends Record<string, any>>(args: Data.IsEqualTo<Omit<A, keyof import("@effect/data/Equal").Equal>, {}> extends true ? void : Omit<A, keyof import("@effect/data/Equal").Equal>) => Data.Data<A & {
+        _tag: "UnsupportedInstance";
+    }>;
+    /** An `Instance` whose specifier is not supported by npm */
+    export class UnsupportedInstance extends UnsupportedInstance_base<BaseInstance<unknown>> {
+        setSpecifier: typeof setSpecifier;
+        getSemverSpecifier(): Option.Option<string>;
+    }
+    export type Any = FileInstance | HostedGitInstance | UrlInstance | AliasInstance | VersionInstance | RangeInstance | TagInstance | WorkspaceProtocolInstance | UnsupportedInstance;
+    export {};
+}
+/**
+ * In the case of banned dependencies, their version is set to `undefined`,
+ * which causes them to be removed by `JSON.stringify`.
+ */
+declare function setSpecifier(this: Instance.Any, version: string | Delete): void;
+export {};

package/dist/instance/index.js

@@ -0,0 +1,154 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Instance = void 0;
+const Data = __importStar(require("@effect/data/Data"));
+const Function_1 = require("@effect/data/Function");
+const Option = __importStar(require("@effect/data/Option"));
+const delete_1 = require("../get-version-groups/lib/delete");
+const _R_1 = require("../lib/$R");
+var Instance;
+(function (Instance) {
+    /** An `Instance` whose specifier is a path to a local file or directory */
+    class FileInstance extends Data.TaggedClass('FileInstance') {
+        constructor() {
+            super(...arguments);
+            this.setSpecifier = setSpecifier;
+        }
+        getSemverSpecifier() {
+            return Option.none();
+        }
+    }
+    Instance.FileInstance = FileInstance;
+    /** An `Instance` whose specifier is a Git URL */
+    class HostedGitInstance extends Data.TaggedClass('HostedGitInstance') {
+        constructor() {
+            super(...arguments);
+            this.setSpecifier = setSpecifier;
+        }
+        getSemverSpecifier() {
+            // @TODO: If git tag is semver, return that
+            return Option.none();
+        }
+    }
+    Instance.HostedGitInstance = HostedGitInstance;
+    /** An `Instance` whose specifier is a URL to a tarball */
+    class UrlInstance extends Data.TaggedClass('URLInstance') {
+        constructor() {
+            super(...arguments);
+            this.setSpecifier = setSpecifier;
+        }
+        getSemverSpecifier() {
+            // @TODO: If file name is semver, return that
+            return Option.none();
+        }
+    }
+    Instance.UrlInstance = UrlInstance;
+    /** An `Instance` whose specifier is eg "npm:imageoptim-cli@3.1.7" */
+    class AliasInstance extends Data.TaggedClass('AliasInstance') {
+        setSpecifier(version) {
+            if (version === delete_1.DELETE) {
+                setSpecifier.call(this, version);
+            }
+            else {
+                const subSpec = this.parsedSpecifier.subSpec;
+                const name = subSpec.name || '';
+                const specifier = `npm:${name}@${version}`;
+                setSpecifier.call(this, specifier);
+            }
+        }
+        getSemverSpecifier() {
+            const subSpec = this.parsedSpecifier.subSpec;
+            if (['range', 'version'].includes(subSpec.type) && subSpec.fetchSpec !== null) {
+                return Option.some(subSpec.fetchSpec);
+            }
+            return Option.none();
+        }
+    }
+    Instance.AliasInstance = AliasInstance;
+    /** An `Instance` whose specifier is exact semver */
+    class VersionInstance extends Data.TaggedClass('VersionInstance') {
+        constructor() {
+            super(...arguments);
+            this.setSpecifier = setSpecifier;
+        }
+        getSemverSpecifier() {
+            return Option.some(this.parsedSpecifier.fetchSpec);
+        }
+    }
+    Instance.VersionInstance = VersionInstance;
+    /** An `Instance` whose specifier is eg. "*" or "^1.2.3" */
+    class RangeInstance extends Data.TaggedClass('RangeInstance') {
+        constructor() {
+            super(...arguments);
+            this.setSpecifier = setSpecifier;
+        }
+        getSemverSpecifier() {
+            return Option.some(this.parsedSpecifier.fetchSpec);
+        }
+    }
+    Instance.RangeInstance = RangeInstance;
+    /** An `Instance` whose specifier is eg. "latest" or "made-up-by-some-dev" */
+    class TagInstance extends Data.TaggedClass('TagInstance') {
+        constructor() {
+            super(...arguments);
+            this.setSpecifier = setSpecifier;
+        }
+        getSemverSpecifier() {
+            return Option.none();
+        }
+    }
+    Instance.TagInstance = TagInstance;
+    /** An `Instance` whose specifier is "workspace:*" */
+    class WorkspaceProtocolInstance extends Data.TaggedClass('WorkspaceProtocolInstance') {
+        constructor() {
+            super(...arguments);
+            this.setSpecifier = setSpecifier;
+        }
+        getSemverSpecifier() {
+            return Option.none();
+        }
+    }
+    Instance.WorkspaceProtocolInstance = WorkspaceProtocolInstance;
+    /** An `Instance` whose specifier is not supported by npm */
+    class UnsupportedInstance extends Data.TaggedClass('UnsupportedInstance') {
+        constructor() {
+            super(...arguments);
+            this.setSpecifier = setSpecifier;
+        }
+        getSemverSpecifier() {
+            return Option.none();
+        }
+    }
+    Instance.UnsupportedInstance = UnsupportedInstance;
+})(Instance || (exports.Instance = Instance = {}));
+/**
+ * In the case of banned dependencies, their version is set to `undefined`,
+ * which causes them to be removed by `JSON.stringify`.
+ */
+function setSpecifier(version) {
+    const file = this.packageJsonFile;
+    (0, Function_1.pipe)(this.strategy.write(file, [this.name, version]), _R_1.$R.tapErrVerbose);
+}