@monorepolint/rules 0.5.0-beta.1 → 0.5.0-beta.10

package/build/types/__tests__/packageScript.spec.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+export {};
+//# sourceMappingURL=packageScript.spec.d.ts.map

package/build/types/__tests__/packageScript.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageScript.spec.d.ts","sourceRoot":"","sources":["../../../src/__tests__/packageScript.spec.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/build/types/__tests__/requireDependency.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=requireDependency.spec.d.ts.map

package/build/types/__tests__/requireDependency.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireDependency.spec.d.ts","sourceRoot":"","sources":["../../../src/__tests__/requireDependency.spec.ts"],"names":[],"mappings":""}

package/build/types/__tests__/utils.d.ts

@@ -0,0 +1,81 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { AddErrorOptions, WorkspaceContext } from "@monorepolint/config";
+import { Host } from "@monorepolint/utils";
+import { jest } from "@jest/globals";
+export declare function jsonToString(obj: unknown): string;
+interface TestingWorkspaceOpts {
+    host: Host;
+    rootProjectName?: string;
+    fixFlag: boolean;
+}
+export declare function createTestingWorkspace(inboundOpts: TestingWorkspaceOpts): Promise<DefaultTestingWorkspace>;
+interface RealTestingWorkspaceOpts extends Required<TestingWorkspaceOpts> {
+    rootPath: string;
+}
+export interface TestingWorkspace {
+    /**
+     * Adds a utf8 file to `packageName` with `relativePath` to the package directory.
+     *
+     * @param packageName The child package to add to or undefined for root package
+     * @param filePath The path of the file to be written. Will be prepended with package dir
+     * @param contents the contents to be written (as utf8)
+     */
+    writeFile(filePath: string, contents: string): void;
+    writeJsonFile(filePath: string, json: object): void;
+    addProject(name: string, fields: object): void;
+    getFilePath(filePath: string): string;
+    readFile(filePath: string): string;
+    /**
+     * Helper method for matching failures via jest `expect().toMatchObject
+     *
+     */
+    failureMatcher(opts: {
+        file: string;
+        message: string;
+        hasFixer: boolean;
+    }): any;
+    readonly context: WorkspaceContext;
+}
+declare class DefaultTestingWorkspace implements TestingWorkspace {
+    private opts;
+    readonly context: WorkspaceContext;
+    constructor(opts: RealTestingWorkspaceOpts, context: WorkspaceContext);
+    addProject(name: string, fields: object): void;
+    writeJsonFile(filePath: string, json: object): void;
+    /**
+     * Adds a utf8 file to `packageName` with `relativePath` to the package directory.
+     *
+     * @param packageName The child package to add to or undefined for root package
+     * @param filePath The path of the file to be written. Will be prepended with package dir
+     * @param contents the contents to be written (as utf8)
+     */
+    writeFile(filePath: string, contents: string): void;
+    getFilePath(filePath: string): string;
+    readFile(filePath: string): string;
+    failureMatcher(opts: {
+        file: string;
+        message: string;
+        hasFixer: boolean;
+    }): {
+        fixer?: {
+            asymmetricMatch(other: unknown): boolean;
+            toString(): string;
+            getExpectedType?(): string;
+            toAsymmetricMatcher?(): string;
+        } | undefined;
+        file: string;
+        message: string;
+    };
+}
+export type AddErrorSpy = jest.SpiedFunction<(options: AddErrorOptions) => void>;
+export declare const HOST_FACTORIES: Array<{
+    name: string;
+    make: () => Host;
+}>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/build/types/__tests__/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEzE,OAAO,EAAe,IAAI,EAAc,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAU,IAAI,EAAE,MAAM,eAAe,CAAC;AAI7C,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,UAExC;AAED,UAAU,oBAAoB;IAC5B,IAAI,EAAE,IAAI,CAAC;IACX,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wBAAsB,sBAAsB,CAAC,WAAW,EAAE,oBAAoB,oCAuB7E;AAED,UAAU,wBAAyB,SAAQ,QAAQ,CAAC,oBAAoB,CAAC;IACvE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpD,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IAEnC;;;OAGG;IACH,cAAc,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,GAAG,GAAG,CAAC;IAEhF,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;CACpC;AAED,cAAM,uBAAwB,YAAW,gBAAgB;IAErD,OAAO,CAAC,IAAI;aACI,OAAO,EAAE,gBAAgB;gBADjC,IAAI,EAAE,wBAAwB,EACtB,OAAO,EAAE,gBAAgB;IAG3C,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAOvC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAI5C;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IAM5C,WAAW,CAAC,QAAQ,EAAE,MAAM;IAI5B,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAIzB,cAAc,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE;;;;;;;;;;CAO1E;AAED,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC,CAAC;AAEjF,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,IAAI,CAAA;CAAE,CAGpE,CAAC"}

package/build/types/alphabeticalDependencies.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+export declare const alphabeticalDependencies: import("./util/createRuleFactory.js").RuleFactoryFn<undefined>;
+//# sourceMappingURL=alphabeticalDependencies.d.ts.map

package/build/types/alphabeticalDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphabeticalDependencies.d.ts","sourceRoot":"","sources":["../../src/alphabeticalDependencies.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,eAAO,MAAM,wBAAwB,gEAQnC,CAAC"}

package/build/types/alphabeticalScripts.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+export declare const alphabeticalScripts: import("./util/createRuleFactory.js").RuleFactoryFn<undefined>;
+//# sourceMappingURL=alphabeticalScripts.d.ts.map

package/build/types/alphabeticalScripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphabeticalScripts.d.ts","sourceRoot":"","sources":["../../src/alphabeticalScripts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,eAAO,MAAM,mBAAmB,gEAM9B,CAAC"}

package/build/types/bannedDependencies.d.ts

@@ -0,0 +1,48 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import * as r from "runtypes";
+declare const Options: r.Union<[r.Record<{
+    bannedDependencies: r.Union<[r.Array<r.String, false>, r.Record<{
+        glob: r.Optional<r.Array<r.String, false>>;
+        exact: r.Optional<r.Array<r.String, false>>;
+    }, false>]>;
+    bannedTransitiveDependencies: r.Optional<r.Literal<undefined>>;
+}, false>, r.Record<{
+    bannedDependencies: r.Optional<r.Union<[r.Array<r.String, false>, r.Record<{
+        glob: r.Optional<r.Array<r.String, false>>;
+        exact: r.Optional<r.Array<r.String, false>>;
+    }, false>]>>;
+    bannedTransitiveDependencies: r.Array<r.String, false>;
+}, false>, r.Record<{
+    bannedDependencies: r.Optional<r.Union<[r.Array<r.String, false>, r.Record<{
+        glob: r.Optional<r.Array<r.String, false>>;
+        exact: r.Optional<r.Array<r.String, false>>;
+    }, false>]>>;
+    bannedTransitiveDependencies: r.Optional<r.Array<r.String, false>>;
+}, false>]>;
+export type Options = r.Static<typeof Options>;
+export declare const bannedDependencies: import("./util/createRuleFactory.js").RuleFactoryFn<{
+    bannedDependencies: string[] | {
+        glob?: string[] | undefined;
+        exact?: string[] | undefined;
+    };
+    bannedTransitiveDependencies?: undefined;
+} | {
+    bannedTransitiveDependencies: string[];
+    bannedDependencies?: string[] | {
+        glob?: string[] | undefined;
+        exact?: string[] | undefined;
+    } | undefined;
+} | {
+    bannedDependencies?: string[] | {
+        glob?: string[] | undefined;
+        exact?: string[] | undefined;
+    } | undefined;
+    bannedTransitiveDependencies?: string[] | undefined;
+}>;
+export {};
+//# sourceMappingURL=bannedDependencies.d.ts.map

package/build/types/bannedDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bannedDependencies.d.ts","sourceRoot":"","sources":["../../src/bannedDependencies.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAa9B,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;WAeZ,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAU/C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EA8D7B,CAAC"}

package/build/types/consistentDependencies.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import * as r from "runtypes";
+declare const Options: r.Union<[r.Record<{
+    ignoredDependencies: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+}, false>, r.Literal<undefined>]>;
+export type Options = r.Static<typeof Options>;
+export declare const consistentDependencies: import("./util/createRuleFactory.js").RuleFactoryFn<{
+    ignoredDependencies: string[] | undefined;
+} | undefined>;
+export {};
+//# sourceMappingURL=consistentDependencies.d.ts.map

package/build/types/consistentDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistentDependencies.d.ts","sourceRoot":"","sources":["../../src/consistentDependencies.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,QAAA,MAAM,OAAO;;iCAIK,CAAC;AACnB,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAI/C,eAAO,MAAM,sBAAsB;;cAQjC,CAAC"}

package/build/types/consistentVersions.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2020 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import * as r from "runtypes";
+export declare const Options: r.Record<{
+    matchDependencyVersions: r.Dictionary<r.Union<[r.String, r.Array<r.String, false>]>, string | number | symbol>;
+}, false>;
+export type Options = r.Static<typeof Options>;
+export declare const consistentVersions: import("./util/createRuleFactory.js").RuleFactoryFn<{
+    matchDependencyVersions: {
+        [x: string]: string | string[];
+        [x: number]: string | string[];
+        [x: symbol]: string | string[];
+    };
+}>;
+//# sourceMappingURL=consistentVersions.d.ts.map

package/build/types/consistentVersions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistentVersions.d.ts","sourceRoot":"","sources":["../../src/consistentVersions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAG9B,eAAO,MAAM,OAAO;;SAElB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAE/C,eAAO,MAAM,kBAAkB;;;;;;EAI7B,CAAC"}

package/build/types/fileContents.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright 2023 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import { Context } from "@monorepolint/config";
+export declare const fileContents: import("./util/createRuleFactory.js").RuleFactoryFn<{
+    file: string;
+    generator: (context: Context) => string | Promise<string>;
+    template?: undefined;
+    templateFile?: undefined;
+} | {
+    file: string;
+    template: string;
+    generator?: undefined;
+    templateFile?: undefined;
+} | {
+    file: string;
+    templateFile: string;
+    generator?: undefined;
+    template?: undefined;
+}>;
+//# sourceMappingURL=fileContents.d.ts.map

package/build/types/fileContents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileContents.d.ts","sourceRoot":"","sources":["../../src/fileContents.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AA8B/C,eAAO,MAAM,YAAY;;yBAtB+B,OAAO,KAAK,MAAM,GAAG,QAAQ,MAAM,CAAC;;;;;;;;;;;;;EA+C1F,CAAC"}

package/build/types/index.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+export { alphabeticalDependencies } from "./alphabeticalDependencies.js";
+export { alphabeticalScripts } from "./alphabeticalScripts.js";
+export { bannedDependencies } from "./bannedDependencies.js";
+export { consistentDependencies } from "./consistentDependencies.js";
+export { consistentVersions } from "./consistentVersions.js";
+export { fileContents } from "./fileContents.js";
+export { mustSatisfyPeerDependencies } from "./mustSatisfyPeerDependencies.js";
+export { packageOrder } from "./packageOrder.js";
+export { packageEntry } from "./packageEntry.js";
+export { packageScript } from "./packageScript.js";
+export { standardTsconfig } from "./standardTsconfig.js";
+export { nestedWorkspaces } from "./nestedWorkspaces.js";
+export { requireDependency } from "./requireDependency.js";
+export { createRuleFactory, RuleCheckFn, RuleFactoryFn, RuleFactoryOptions, ValidateOptionsFn, } from "./util/createRuleFactory.js";
+//# sourceMappingURL=index.d.ts.map

package/build/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,6BAA6B,CAAC"}

package/build/types/mustSatisfyPeerDependencies.d.ts

@@ -0,0 +1,333 @@
+/*!
+ * Copyright 2020 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import * as r from "runtypes";
+declare const Options: r.Union<[r.Partial<{
+    skipUnparseableRanges: r.Literal<undefined>;
+    dependencyWhitelist: r.Literal<undefined>;
+    dependencyBlacklist: r.Literal<undefined>;
+    enforceForDevDependencies: r.Literal<undefined>;
+}, false>, r.Intersect<[r.Record<{
+    skipUnparseableRanges: r.Boolean;
+}, false>, r.Partial<{
+    dependencyWhitelist: r.Literal<undefined>;
+    dependencyBlacklist: r.Literal<undefined>;
+    enforceForDevDependencies: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    dependencyWhitelist: r.Array<r.String, false>;
+}, false>, r.Partial<{
+    skipUnparseableRanges: r.Literal<undefined>;
+    dependencyBlacklist: r.Literal<undefined>;
+    enforceForDevDependencies: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    dependencyBlacklist: r.Array<r.String, false>;
+}, false>, r.Partial<{
+    skipUnparseableRanges: r.Literal<undefined>;
+    dependencyWhitelist: r.Literal<undefined>;
+    enforceForDevDependencies: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    enforceForDevDependencies: r.Boolean;
+}, false>, r.Partial<{
+    skipUnparseableRanges: r.Literal<undefined>;
+    dependencyWhitelist: r.Literal<undefined>;
+    dependencyBlacklist: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    skipUnparseableRanges: r.Boolean;
+    dependencyWhitelist: r.Array<r.String, false>;
+}, false>, r.Partial<{
+    dependencyBlacklist: r.Literal<undefined>;
+    enforceForDevDependencies: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    skipUnparseableRanges: r.Boolean;
+    dependencyBlacklist: r.Array<r.String, false>;
+}, false>, r.Partial<{
+    dependencyWhitelist: r.Literal<undefined>;
+    enforceForDevDependencies: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    skipUnparseableRanges: r.Boolean;
+    enforceForDevDependencies: r.Boolean;
+}, false>, r.Partial<{
+    dependencyWhitelist: r.Literal<undefined>;
+    dependencyBlacklist: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    dependencyWhitelist: r.Array<r.String, false>;
+    dependencyBlacklist: r.Array<r.String, false>;
+}, false>, r.Partial<{
+    skipUnparseableRanges: r.Literal<undefined>;
+    enforceForDevDependencies: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    dependencyWhitelist: r.Array<r.String, false>;
+    enforceForDevDependencies: r.Boolean;
+}, false>, r.Partial<{
+    skipUnparseableRanges: r.Literal<undefined>;
+    dependencyBlacklist: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    dependencyBlacklist: r.Array<r.String, false>;
+    enforceForDevDependencies: r.Boolean;
+}, false>, r.Partial<{
+    skipUnparseableRanges: r.Literal<undefined>;
+    dependencyWhitelist: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    skipUnparseableRanges: r.Boolean;
+    dependencyWhitelist: r.Array<r.String, false>;
+    dependencyBlacklist: r.Array<r.String, false>;
+}, false>, r.Partial<{
+    enforceForDevDependencies: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    skipUnparseableRanges: r.Boolean;
+    dependencyWhitelist: r.Array<r.String, false>;
+    enforceForDevDependencies: r.Boolean;
+}, false>, r.Partial<{
+    dependencyBlacklist: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    skipUnparseableRanges: r.Boolean;
+    dependencyBlacklist: r.Array<r.String, false>;
+    enforceForDevDependencies: r.Boolean;
+}, false>, r.Partial<{
+    dependencyWhitelist: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    dependencyWhitelist: r.Array<r.String, false>;
+    dependencyBlacklist: r.Array<r.String, false>;
+    enforceForDevDependencies: r.Boolean;
+}, false>, r.Partial<{
+    skipUnparseableRanges: r.Literal<undefined>;
+}, false>]>, r.Record<{
+    skipUnparseableRanges: r.Boolean;
+    dependencyWhitelist: r.Array<r.String, false>;
+    dependencyBlacklist: r.Array<r.String, false>;
+    enforceForDevDependencies: r.Boolean;
+}, false>]>;
+export type Options = r.Static<typeof Options>;
+export declare const mustSatisfyPeerDependencies: import("./util/createRuleFactory.js").RuleFactoryFn<{
+    skipUnparseableRanges?: undefined;
+    dependencyWhitelist?: undefined;
+    dependencyBlacklist?: undefined;
+    enforceForDevDependencies?: undefined;
+} | ({
+    skipUnparseableRanges: boolean;
+} & {
+    dependencyWhitelist?: undefined;
+    dependencyBlacklist?: undefined;
+    enforceForDevDependencies?: undefined;
+}) | ({
+    dependencyWhitelist: string[];
+} & {
+    skipUnparseableRanges?: undefined;
+    dependencyBlacklist?: undefined;
+    enforceForDevDependencies?: undefined;
+}) | ({
+    dependencyBlacklist: string[];
+} & {
+    skipUnparseableRanges?: undefined;
+    dependencyWhitelist?: undefined;
+    enforceForDevDependencies?: undefined;
+}) | ({
+    enforceForDevDependencies: boolean;
+} & {
+    skipUnparseableRanges?: undefined;
+    dependencyWhitelist?: undefined;
+    dependencyBlacklist?: undefined;
+}) | ({
+    skipUnparseableRanges: boolean;
+    dependencyWhitelist: string[];
+} & {
+    dependencyBlacklist?: undefined;
+    enforceForDevDependencies?: undefined;
+}) | ({
+    skipUnparseableRanges: boolean;
+    dependencyBlacklist: string[];
+} & {
+    dependencyWhitelist?: undefined;
+    enforceForDevDependencies?: undefined;
+}) | ({
+    skipUnparseableRanges: boolean;
+    enforceForDevDependencies: boolean;
+} & {
+    dependencyWhitelist?: undefined;
+    dependencyBlacklist?: undefined;
+}) | ({
+    dependencyWhitelist: string[];
+    dependencyBlacklist: string[];
+} & {
+    skipUnparseableRanges?: undefined;
+    enforceForDevDependencies?: undefined;
+}) | ({
+    dependencyWhitelist: string[];
+    enforceForDevDependencies: boolean;
+} & {
+    skipUnparseableRanges?: undefined;
+    dependencyBlacklist?: undefined;
+}) | ({
+    dependencyBlacklist: string[];
+    enforceForDevDependencies: boolean;
+} & {
+    skipUnparseableRanges?: undefined;
+    dependencyWhitelist?: undefined;
+}) | ({
+    skipUnparseableRanges: boolean;
+    dependencyWhitelist: string[];
+    dependencyBlacklist: string[];
+} & {
+    enforceForDevDependencies?: undefined;
+}) | ({
+    skipUnparseableRanges: boolean;
+    dependencyWhitelist: string[];
+    enforceForDevDependencies: boolean;
+} & {
+    dependencyBlacklist?: undefined;
+}) | ({
+    skipUnparseableRanges: boolean;
+    dependencyBlacklist: string[];
+    enforceForDevDependencies: boolean;
+} & {
+    dependencyWhitelist?: undefined;
+}) | ({
+    dependencyWhitelist: string[];
+    dependencyBlacklist: string[];
+    enforceForDevDependencies: boolean;
+} & {
+    skipUnparseableRanges?: undefined;
+}) | {
+    skipUnparseableRanges: boolean;
+    dependencyWhitelist: string[];
+    dependencyBlacklist: string[];
+    enforceForDevDependencies: boolean;
+}>;
+/**
+ * separating on `|`, this regex allows any of the following formats:
+ * - `*`
+ * - `x`
+ *
+ * More info: https://docs.npmjs.com/about-semantic-versioning
+ */
+export declare const MATCH_ANY_VERSION_RANGE: RegExp;
+/**
+ * This regex allows any of the following formats:
+ * - `>=15`
+ * - `>=15.2`
+ * - `>=15.2.1`
+ * - `>=15.2.1-rc.0`
+ * - `>=15.2.1+sha`
+ * - `>=15.2.1-rc.0+sha`
+ *
+ * See https://semver.org/#spec-item-9 for details about semver formatting, and
+ * https://regex101.com/r/vkijKf/1/ for a sample Regex.
+ *
+ * Note that the semver spec does _not_ specify npm range syntax. (`^`, `||`, `~`, `>`, etc.)
+ *
+ * More info: https://docs.npmjs.com/about-semantic-versioning
+ */
+export declare const MATCH_GREATER_OR_EQUAL_VERSION_RANGE: RegExp;
+/**
+ * This regex allows any of the following formats:
+ * - `15`
+ * - `^15`
+ * - `15.x`
+ * - `^15.x`
+ * - `15.x.x`
+ * - `^15.x.x`
+ * - `^15.2`
+ * - `^15.2.x`
+ * - `^15.2.1`
+ * - `^15.2.1-rc.0`
+ * - `^15.2.1+sha`
+ * - `^15.2.1-rc.0+sha`
+ *
+ * See https://semver.org/#spec-item-9 for details about semver formatting, and
+ * https://regex101.com/r/vkijKf/1/ for a sample Regex.
+ *
+ * Note that the semver spec does _not_ specify npm range syntax. (`^`, `||`, `~`, `>`, etc.)
+ *
+ * More info: https://docs.npmjs.com/about-semantic-versioning
+ */
+export declare const MATCH_MAJOR_VERSION_RANGE: RegExp;
+/**
+ * Does not currently accept `<`, `<=`, `>`, `=` or `-` for ranges (e.g. `> 2.5.1 < 3` or `1.0.0 - 1.2.0`),
+ * though it will accept isolated `>=` ranges (e.g. `>=2.5.1`, but not `^1 || >=2.5.1`)
+ *
+ * See https://semver.org/#spec-item-9 for details about semver formatting, and
+ * https://regex101.com/r/vkijKf/1/ for a sample Regex.
+ *
+ * Note that the semver spec does _not_ specify npm range syntax. (`^`, `||`, `~`, `>`, etc.)
+ *
+ * More info: https://docs.npmjs.com/about-semantic-versioning
+ *
+ * TODO: accept minor pins `~4.2.1`
+ */
+export declare const RANGE_REGEX: RegExp;
+/**
+ * Given two version ranges, find the maximum intersecting range
+ * of `a` and `b`. `findIntersection(a,b)` should return the same
+ * result as `findIntersection(b,a)`.
+ *
+ * NOTE: This code assumes that input version ranges match `RANGE_REGEX`.
+ * Additionally, major version ranges must not be repeated in union ranges.
+ * e.g. `^15.0.5 || ^16.0.0` is permitted, but `15.0.5 || 15.0.999` is not.
+ *
+ * EXAMPLES:
+ * findIntersection("15.1.0", "*") => "15.1.0"
+ * findIntersection("^15", "*") => "^15"
+ * findIntersection(">=15", "*") => ">=15"
+ * findIntersection("*", "*") => "*"
+ * findIntersection("15.1.0", ">=1") => "15.1.0"
+ * findIntersection("^15", ">=1") => "^15"
+ * findIntersection(">=15", ">=1") => ">=15"
+ * findIntersection("15.1.0", "^15") => "15.1.0"
+ * findIntersection("^15.2", "^15") => "^15.2"
+ * findIntersection("14", "^15") => undefined
+ * findIntersection("15.1.0", "^15 || ^16") => "15.1.0"
+ * findIntersection("^15.2", "^15 || ^16") => "^15.2"
+ * findIntersection("14", "^15 || ^16") => undefined
+ * findIntersection("^15.2 || ^16", "^15 || ^16.4") => "^15.2 || ^16.4"
+ *
+ * @param a version range that matches `RANGE_REGEX`
+ * @param b version range that matches `RANGE_REGEX`
+ * @returns the maximum intersecting `ValidRange`, or `undefined` if there is no intersection
+ */
+export declare function findIntersection(a: ValidRange, b: ValidRange): ValidRange | undefined;
+/**
+ * Given two version ranges, determine whether `a` satisfies `b`.
+ * `a` satisfies `b` iff `a` is a "more strict than or equal to" subset of `b`.
+ * For example, both `^15` and `^15.2.0` satisfy `^15`, but `^15 || ^16` does not.
+ *
+ * NOTE: This code assumes that input version ranges match `RANGE_REGEX`.
+ * Additionally, major version ranges must not be repeated in union ranges.
+ * e.g. `^15.0.5 || ^16.0.0` is permitted, but `15.0.5 || 15.0.999` is not.
+ *
+ * To determine that `a` is "more strict than or equal to" `b`, we first
+ * split the set of all versions or ranges that are potentially unioned in `a` and `b`.
+ * For example, if `a` is `15.0.5`, we produce the set `[ "15.0.5" ]`,
+ * and if `b` is `^15 || ^16`, we produce the set `[ "^15", "^16" ]`.
+ * `a` is "more strict than or equal to" `b` iff each entry in `a`'s set
+ * satisfies (equal to or greater than) some entry in `b`.
+ *
+ * The following version ranges satisfy `^15.0.5 || ^16.0.0`:
+ * - `^15.0.5 || ^16.0.0`
+ * - `^15.0.5 || ^16.x.x`
+ * - `15.0.5 || 16.0.0`
+ * - `^15.0.999 || ^16.0.0`
+ * - `^15.0.5 || ^16.0.999`
+ * - `^15.0.999`
+ * - `^16.0.0`
+ * - `16.0.0`
+ * The following version ranges do not satisfy `^15.0.5 || ^16.0.0`:
+ * - `^15.0.0 || ^16.0.0`
+ * - `^15.0.5 || ^17.0.0`
+ * - `^14.0.0 || ^15.0.5 || ^16.0.0`
+ * - `^17.0.0`
+ * - `17.0.0`
+ *
+ * @param a version range that matches `RANGE_REGEX`
+ * @param b version range that matches `RANGE_REGEX`
+ * @returns `true` if `a` is more strict than or equal to `b`, `false` otherwise
+ */
+export declare function doesASatisfyB(a: ValidRange, b: ValidRange): boolean;
+export type ValidRange = string & {
+    _type: "valid range";
+};
+export declare function isValidRange(version: string): version is ValidRange;
+export {};
+//# sourceMappingURL=mustSatisfyPeerDependencies.d.ts.map

package/build/types/mustSatisfyPeerDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mustSatisfyPeerDependencies.d.ts","sourceRoot":"","sources":["../../src/mustSatisfyPeerDependencies.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAK9B,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuKZ,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAE/C,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,QAAa,CAAC;AAElD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oCAAoC,QAC0H,CAAC;AAE5K;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,yBAAyB,QACmL,CAAC;AAE1N;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,QACghB,CAAC;AAyNziB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAoFrF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAmEnE;AAoBD,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,aAAa,CAAA;CAAE,CAAC;AAC3D,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,UAAU,CAEnE"}

package/build/types/nestedWorkspaces.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+import * as r from "runtypes";
+export declare const Options: r.Literal<undefined>;
+export declare const nestedWorkspaces: import("./util/createRuleFactory.js").RuleFactoryFn<unknown>;
+//# sourceMappingURL=nestedWorkspaces.d.ts.map

package/build/types/nestedWorkspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestedWorkspaces.d.ts","sourceRoot":"","sources":["../../src/nestedWorkspaces.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAG9B,eAAO,MAAM,OAAO,sBAAc,CAAC;AAKnC,eAAO,MAAM,gBAAgB,8DA0C3B,CAAC"}