@monorepolint/rules 0.5.0-alpha.11 → 0.5.0-alpha.124

package/build/types/mustSatisfyPeerDependencies.d.ts

@@ -0,0 +1,427 @@
+/*!
+ * 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: (ruleEntry: import("@monorepolint/config").RuleEntry<{
+    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;
+}>) => import("@monorepolint/config").RuleModule<{
+    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: (ruleEntry: import("@monorepolint/config").RuleEntry<unknown>) => import("@monorepolint/config").RuleModule<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,sHA0C3B,CAAC"}

package/build/types/packageEntry.d.ts

@@ -0,0 +1,62 @@
+/*!
+ * 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.Union<[r.Intersect<[r.Record<{
+    entries: r.Dictionary<r.Unknown, string | number | symbol>;
+}, false>, r.Partial<{
+    entriesExist: r.Literal<undefined>;
+}, false>]>, r.Intersect<[r.Record<{
+    entriesExist: r.Array<r.String, false>;
+}, false>, r.Partial<{
+    entries: r.Literal<undefined>;
+}, false>]>, r.Record<{
+    entries: r.Dictionary<r.Unknown, string | number | symbol>;
+    entriesExist: r.Array<r.String, false>;
+}, false>]>;
+export type Options = r.Static<typeof Options>;
+export declare const packageEntry: (ruleEntry: import("@monorepolint/config").RuleEntry<({
+    entries: {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+    };
+} & {
+    entriesExist?: undefined;
+}) | ({
+    entriesExist: string[];
+} & {
+    entries?: undefined;
+}) | {
+    entries: {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+    };
+    entriesExist: string[];
+}>) => import("@monorepolint/config").RuleModule<({
+    entries: {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+    };
+} & {
+    entriesExist?: undefined;
+}) | ({
+    entriesExist: string[];
+} & {
+    entries?: undefined;
+}) | {
+    entries: {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+    };
+    entriesExist: string[];
+}>;
+export declare function createStandardizedEntryErrorMessage(key: string): string;
+export declare function createExpectedEntryErrorMessage(key: string): string;
+//# sourceMappingURL=packageEntry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"packageEntry.d.ts","sourceRoot":"","sources":["../../src/packageEntry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAG9B,eAAO,MAAM,OAAO;;;;;;;;;;;WAuBnB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAE/C,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CvB,CAAC;AAEH,wBAAgB,mCAAmC,CAAC,GAAG,EAAE,MAAM,UAE9D;AAED,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,UAE1D"}

package/build/types/packageOrder.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+export declare const packageOrder: (ruleEntry: import("@monorepolint/config").RuleEntry<{
+    order: string[] | ((...args: any[]) => any);
+} | undefined>) => import("@monorepolint/config").RuleModule<{
+    order: string[] | ((...args: any[]) => any);
+} | undefined>;
+//# sourceMappingURL=packageOrder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"packageOrder.d.ts","sourceRoot":"","sources":["../../src/packageOrder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAgDH,eAAO,MAAM,YAAY;;;;cAgCvB,CAAC"}

package/build/types/packageScript.d.ts

@@ -0,0 +1,47 @@
+/*!
+ * 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.Record<{
+    scripts: r.Dictionary<r.Union<[r.String, r.Record<{
+        options: r.Array<r.Union<[r.String, r.Literal<undefined>]>, false>;
+        fixValue: r.Optional<r.Union<[r.String, r.Literal<undefined>, r.Literal<false>]>>;
+    }, false>]>, string | number | symbol>;
+}, false>;
+export type Options = r.Static<typeof Options>;
+export declare const MSG_NO_SCRIPTS_BLOCK = "No scripts block in package.json";
+export declare const packageScript: (ruleEntry: import("@monorepolint/config").RuleEntry<{
+    scripts: {
+        [x: string]: string | {
+            options: (string | undefined)[];
+            fixValue?: string | false | undefined;
+        };
+        [x: number]: string | {
+            options: (string | undefined)[];
+            fixValue?: string | false | undefined;
+        };
+        [x: symbol]: string | {
+            options: (string | undefined)[];
+            fixValue?: string | false | undefined;
+        };
+    };
+}>) => import("@monorepolint/config").RuleModule<{
+    scripts: {
+        [x: string]: string | {
+            options: (string | undefined)[];
+            fixValue?: string | false | undefined;
+        };
+        [x: number]: string | {
+            options: (string | undefined)[];
+            fixValue?: string | false | undefined;
+        };
+        [x: symbol]: string | {
+            options: (string | undefined)[];
+            fixValue?: string | false | undefined;
+        };
+    };
+}>;
+//# sourceMappingURL=packageScript.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"packageScript.d.ts","sourceRoot":"","sources":["../../src/packageScript.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAG9B,eAAO,MAAM,OAAO;;;;;SAUlB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAE/C,eAAO,MAAM,oBAAoB,qCAAqC,CAAC;AAEvE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsExB,CAAC"}

package/build/types/public/util.d.ts

@@ -0,0 +1,2 @@
+export { makeRule } from "../util/makeRule.js";
+//# sourceMappingURL=util.d.ts.map

package/build/types/public/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/public/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC"}

package/build/types/requireDependency.d.ts

@@ -0,0 +1,50 @@
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+export declare const requireDependency: (ruleEntry: import("@monorepolint/config").RuleEntry<{
+    dependencies?: {
+        [x: string]: string;
+        [x: number]: string;
+        [x: symbol]: string;
+    } | undefined;
+    devDependencies?: {
+        [x: string]: string;
+        [x: number]: string;
+        [x: symbol]: string;
+    } | undefined;
+    peerDependencies?: {
+        [x: string]: string;
+        [x: number]: string;
+        [x: symbol]: string;
+    } | undefined;
+    optionalDependencies?: {
+        [x: string]: string;
+        [x: number]: string;
+        [x: symbol]: string;
+    } | undefined;
+}>) => import("@monorepolint/config").RuleModule<{
+    dependencies?: {
+        [x: string]: string;
+        [x: number]: string;
+        [x: symbol]: string;
+    } | undefined;
+    devDependencies?: {
+        [x: string]: string;
+        [x: number]: string;
+        [x: symbol]: string;
+    } | undefined;
+    peerDependencies?: {
+        [x: string]: string;
+        [x: number]: string;
+        [x: symbol]: string;
+    } | undefined;
+    optionalDependencies?: {
+        [x: string]: string;
+        [x: number]: string;
+        [x: symbol]: string;
+    } | undefined;
+}>;
+//# sourceMappingURL=requireDependency.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requireDependency.d.ts","sourceRoot":"","sources":["../../src/requireDependency.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAiBH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgD5B,CAAC"}

package/build/types/standardTsconfig.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * 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.Constraint<r.Partial<{
+    file: r.String;
+    generator: r.Function;
+    tsconfigReferenceFile: r.String;
+    template: r.Union<[r.Record<{}, false>, r.String]>;
+    templateFile: r.String;
+    excludedReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+    additionalReferences: r.Union<[r.Array<r.String, false>, r.Literal<undefined>]>;
+}, false>, {
+    file?: string | undefined;
+    generator?: ((...args: any[]) => any) | undefined;
+    tsconfigReferenceFile?: string | undefined;
+    template?: string | {} | undefined;
+    templateFile?: string | undefined;
+    excludedReferences?: string[] | undefined;
+    additionalReferences?: string[] | undefined;
+}, unknown>;
+export interface Options extends r.Static<typeof Options> {
+}
+export declare const standardTsconfig: (ruleEntry: import("@monorepolint/config").RuleEntry<Options>) => import("@monorepolint/config").RuleModule<Options>;
+export {};
+//# sourceMappingURL=standardTsconfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"standardTsconfig.d.ts","sourceRoot":"","sources":["../../src/standardTsconfig.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAK9B,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;WAuBT,CAAC;AAEL,MAAM,WAAW,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC;CAAG;AAE5D,eAAO,MAAM,gBAAgB,sHAkC3B,CAAC"}