@monorepolint/rules 0.5.0-alpha.103 → 0.5.0-alpha.107

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

@@ -1 +1 @@
-{"version":3,"file":"mustSatisfyPeerDependencies.d.ts","sourceRoot":"","sources":["../../src/mustSatisfyPeerDependencies.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,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,EAAE,UAAU,CAAC,OAAO,OAAO,CAGlE,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGvC,CAAC;AAEF;;;;;;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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAItC,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

@@ -4,21 +4,7 @@
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
-import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
 export declare const Options: r.Literal<undefined>;
-type Options = r.Static<typeof Options>;
-export declare const nestedWorkspaces: RuleModule<typeof Options>;
-export declare const NestedWorkspaces: {
-    new (ruleEntry: import("@monorepolint/config").RuleEntry<undefined>): {
-        readonly id: string;
-        options: undefined;
-        readonly name: string;
-        checkFunc: import("@monorepolint/config").Checker<r.Literal<undefined>>;
-        readonly optionsRuntype: r.Literal<undefined>;
-        readonly ruleEntry: import("@monorepolint/config").RuleEntry<undefined>;
-        check: (context: Context) => void | Promise<void>;
-    };
-};
-export {};
+export declare const nestedWorkspaces: (ruleEntry: import("@monorepolint/config").RuleEntry<undefined>) => import("@monorepolint/config").RuleModule<r.Literal<undefined>>;
 //# sourceMappingURL=nestedWorkspaces.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"nestedWorkspaces.d.ts","sourceRoot":"","sources":["../../src/nestedWorkspaces.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,eAAO,MAAM,OAAO,sBAAc,CAAC;AAEnC,KAAK,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAGxC,eAAO,MAAM,gBAAgB,EAAE,UAAU,CAAC,OAAO,OAAO,CAyCvD,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;CAAgE,CAAC"}
+{"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,qIA0C3B,CAAC"}

package/build/types/packageEntry.d.ts

@@ -4,7 +4,6 @@
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
-import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
 export declare const Options: r.Union<[r.Intersect<[r.Record<{
     entries: r.Dictionary<r.Unknown, string | number | symbol>;
@@ -19,97 +18,37 @@ export declare const Options: r.Union<[r.Intersect<[r.Record<{
     entriesExist: r.Array<r.String, false>;
 }, false>]>;
 export type Options = r.Static<typeof Options>;
-export declare const packageEntry: RuleModule<typeof Options>;
-export declare const PackageEntry: {
-    new (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[];
-    }>): {
-        readonly id: string;
-        options: ({
-            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[];
-        } | undefined;
-        readonly name: string;
-        checkFunc: import("@monorepolint/config").Checker<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>]>>;
-        readonly optionsRuntype: 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>]>;
-        readonly 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[];
-        }>;
-        check: (context: Context) => void | Promise<void>;
+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<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 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

@@ -1 +1 @@
-{"version":3,"file":"packageEntry.d.ts","sourceRoot":"","sources":["../../src/packageEntry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,eAAO,MAAM,OAAO;;;;;;;;;;;WAuBnB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC,CAAC;AAE/C,eAAO,MAAM,YAAY,EAAE,UAAU,CAAC,OAAO,OAAO,CAyCnD,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAC;AAElF,wBAAgB,mCAAmC,CAAC,GAAG,EAAE,MAAM,UAE9D;AAED,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,UAE1D"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA0CvB,CAAC;AAEH,wBAAgB,mCAAmC,CAAC,GAAG,EAAE,MAAM,UAE9D;AAED,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,UAE1D"}

package/build/types/packageOrder.d.ts

@@ -4,30 +4,10 @@
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
-import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
-export declare const packageOrder: RuleModule<r.Union<[r.Record<{
+export declare const packageOrder: (ruleEntry: import("@monorepolint/config").RuleEntry<{
+    order: string[] | ((...args: any[]) => any);
+} | undefined>) => import("@monorepolint/config").RuleModule<r.Union<[r.Record<{
     order: r.Union<[r.Array<r.String, false>, r.Function]>;
 }, false>, r.Literal<undefined>]>>;
-export declare const PackageOrder: {
-    new (ruleEntry: import("@monorepolint/config").RuleEntry<{
-        order: ((...args: any[]) => any) | string[];
-    } | undefined>): {
-        readonly id: string;
-        options: {
-            order: ((...args: any[]) => any) | string[];
-        } | undefined;
-        readonly name: string;
-        checkFunc: import("@monorepolint/config").Checker<r.Union<[r.Record<{
-            order: r.Union<[r.Array<r.String, false>, r.Function]>;
-        }, false>, r.Literal<undefined>]>>;
-        readonly optionsRuntype: r.Union<[r.Record<{
-            order: r.Union<[r.Array<r.String, false>, r.Function]>;
-        }, false>, r.Literal<undefined>]>;
-        readonly ruleEntry: import("@monorepolint/config").RuleEntry<{
-            order: ((...args: any[]) => any) | string[];
-        } | undefined>;
-        check: (context: Context) => void | Promise<void>;
-    };
-};
 //# sourceMappingURL=packageOrder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"packageOrder.d.ts","sourceRoot":"","sources":["../../src/packageOrder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AA4C9B,eAAO,MAAM,YAAY;;kCA8BM,CAAC;AAEhC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;CAAwD,CAAC"}
+{"version":3,"file":"packageOrder.d.ts","sourceRoot":"","sources":["../../src/packageOrder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AA4C9B,eAAO,MAAM,YAAY;;;;kCA+BvB,CAAC"}

package/build/types/packageScript.d.ts

@@ -4,7 +4,6 @@
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
-import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
 export declare const Options: r.Record<{
     scripts: r.Dictionary<r.Union<[r.String, r.Record<{
@@ -14,76 +13,25 @@ export declare const Options: r.Record<{
 }, 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: RuleModule<r.Record<{
+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<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 declare const PackageScript: {
-    new (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;
-            };
-        };
-    }>): {
-        readonly id: string;
-        options: {
-            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;
-                };
-            };
-        } | undefined;
-        readonly name: string;
-        checkFunc: import("@monorepolint/config").Checker<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>>;
-        readonly optionsRuntype: 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>;
-        readonly 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;
-                };
-            };
-        }>;
-        check: (context: Context) => void | Promise<void>;
-    };
-};
 //# sourceMappingURL=packageScript.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"packageScript.d.ts","sourceRoot":"","sources":["../../src/packageScript.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAI3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,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;;;;;UAqEK,CAAC;AAEhC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA0D,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;UAsExB,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

@@ -4,96 +4,32 @@
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
-import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
-export declare const requireDependency: RuleModule<r.Partial<{
+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<r.Partial<{
     dependencies: r.Dictionary<r.String, string | number | symbol>;
     devDependencies: r.Dictionary<r.String, string | number | symbol>;
     peerDependencies: r.Dictionary<r.String, string | number | symbol>;
     optionalDependencies: r.Dictionary<r.String, string | number | symbol>;
 }, false>>;
-export declare const RequireDependency: {
-    new (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;
-    }>): {
-        readonly id: string;
-        options: {
-            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;
-        } | undefined;
-        readonly name: string;
-        checkFunc: import("@monorepolint/config").Checker<r.Partial<{
-            dependencies: r.Dictionary<r.String, string | number | symbol>;
-            devDependencies: r.Dictionary<r.String, string | number | symbol>;
-            peerDependencies: r.Dictionary<r.String, string | number | symbol>;
-            optionalDependencies: r.Dictionary<r.String, string | number | symbol>;
-        }, false>>;
-        readonly optionsRuntype: r.Partial<{
-            dependencies: r.Dictionary<r.String, string | number | symbol>;
-            devDependencies: r.Dictionary<r.String, string | number | symbol>;
-            peerDependencies: r.Dictionary<r.String, string | number | symbol>;
-            optionalDependencies: r.Dictionary<r.String, string | number | symbol>;
-        }, false>;
-        readonly 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;
-        }>;
-        check: (context: Context) => void | Promise<void>;
-    };
-};
 //# sourceMappingURL=requireDependency.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"requireDependency.d.ts","sourceRoot":"","sources":["../../src/requireDependency.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAW9B,eAAO,MAAM,iBAAiB;;;;;UA+CC,CAAC;AAEhC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkE,CAAC"}
+{"version":3,"file":"requireDependency.d.ts","sourceRoot":"","sources":["../../src/requireDependency.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAY9B,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;UAgD5B,CAAC"}

package/build/types/standardTsconfig.d.ts

@@ -4,7 +4,6 @@
  * Licensed under the MIT license. See LICENSE file in the project root for details.
  *
  */
-import { Context, RuleModule } from "@monorepolint/config";
 import * as r from "runtypes";
 declare const Options: r.Constraint<r.Partial<{
     file: r.String;
@@ -25,7 +24,15 @@ declare const Options: r.Constraint<r.Partial<{
 }, unknown>;
 export interface Options extends r.Static<typeof Options> {
 }
-export declare const standardTsconfig: RuleModule<r.Constraint<r.Partial<{
+export declare const standardTsconfig: (ruleEntry: import("@monorepolint/config").RuleEntry<{
+    file?: string | undefined;
+    generator?: ((...args: any[]) => any) | undefined;
+    tsconfigReferenceFile?: string | undefined;
+    template?: string | {} | undefined;
+    templateFile?: string | undefined;
+    excludedReferences?: string[] | undefined;
+    additionalReferences?: string[] | undefined;
+}>) => import("@monorepolint/config").RuleModule<r.Constraint<r.Partial<{
     file: r.String;
     generator: r.Function;
     tsconfigReferenceFile: r.String;
@@ -42,72 +49,5 @@ export declare const standardTsconfig: RuleModule<r.Constraint<r.Partial<{
     excludedReferences?: string[] | undefined;
     additionalReferences?: string[] | undefined;
 }, unknown>>;
-export declare const StandardTsConfig: {
-    new (ruleEntry: import("@monorepolint/config").RuleEntry<{
-        file?: string | undefined;
-        generator?: ((...args: any[]) => any) | undefined;
-        tsconfigReferenceFile?: string | undefined;
-        template?: string | {} | undefined;
-        templateFile?: string | undefined;
-        excludedReferences?: string[] | undefined;
-        additionalReferences?: string[] | undefined;
-    }>): {
-        readonly id: string;
-        options: {
-            file?: string | undefined;
-            generator?: ((...args: any[]) => any) | undefined;
-            tsconfigReferenceFile?: string | undefined;
-            template?: string | {} | undefined;
-            templateFile?: string | undefined;
-            excludedReferences?: string[] | undefined;
-            additionalReferences?: string[] | undefined;
-        } | undefined;
-        readonly name: string;
-        checkFunc: import("@monorepolint/config").Checker<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>>;
-        readonly optionsRuntype: 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>;
-        readonly ruleEntry: import("@monorepolint/config").RuleEntry<{
-            file?: string | undefined;
-            generator?: ((...args: any[]) => any) | undefined;
-            tsconfigReferenceFile?: string | undefined;
-            template?: string | {} | undefined;
-            templateFile?: string | undefined;
-            excludedReferences?: string[] | undefined;
-            additionalReferences?: string[] | undefined;
-        }>;
-        check: (context: Context) => void | Promise<void>;
-    };
-};
 export {};
 //# sourceMappingURL=standardTsconfig.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"standardTsconfig.d.ts","sourceRoot":"","sources":["../../src/standardTsconfig.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAK3D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAI9B,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;WAuBT,CAAC;AAEL,MAAM,WAAW,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,OAAO,CAAC;CAAG;AAE5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;YAiCE,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgE,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;YAkC3B,CAAC"}

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

@@ -0,0 +1,13 @@
+import { Context, RuleEntry, RuleModule } from "@monorepolint/config";
+import * as r from "runtypes";
+export declare function makeRule<T extends r.Runtype<unknown>>({ name, check, optionsRuntype, printStats, }: {
+    name: string;
+    check: (context: Context, options: r.Static<T>, extra: {
+        id: string;
+    }) => Promise<unknown> | unknown;
+    optionsRuntype: T;
+    printStats?: () => void;
+}): RuleFunction<T>;
+type RuleFunction<T extends r.Runtype<any>> = (ruleEntry: RuleEntry<r.Static<T>>) => RuleModule<T>;
+export {};
+//# sourceMappingURL=makeRule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeRule.d.ts","sourceRoot":"","sources":["../../../src/util/makeRule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAG9B,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,EACrD,IAAI,EACJ,KAAK,EACL,cAAc,EACd,UAAU,GACX,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACrG,cAAc,EAAE,CAAC,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB,GAAG,YAAY,CAAC,CAAC,CAAC,CAYlB;AAED,KAAK,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monorepolint/rules",
-  "version": "0.5.0-alpha.103+241c1b6",
+  "version": "0.5.0-alpha.107+27faf77",
   "author": "Eric L Anderson (https://github.com/ericanderson)",
   "contributors": [
     "Mac Lockard (https://github.com/maclockard)"
@@ -11,10 +11,16 @@
   "exports": {
     ".": {
       "types": "./build/types/index.d.ts",
-      "import": "./build/js/index.js",
-      "require": "./build/js/index.cjs"
+      "import": "./build/js/index.js"
+    },
+    "./*": {
+      "types": "./build/types/public/*.d.ts",
+      "import": "./build/js/public/*.js"
     }
   },
+  "engines": {
+    "node": ">=16"
+  },
   "scripts": {
     "clean": "rm -rf build dist lib node_modules *.tgz tsconfig.tsbuildinfo",
     "compile-typescript": "tsc --build",
@@ -24,15 +30,15 @@
     "transpile-typescript": "tsup --config ../../tsup.config.cjs"
   },
   "dependencies": {
-    "@monorepolint/config": "^0.5.0-alpha.103+241c1b6",
-    "@monorepolint/core": "^0.5.0-alpha.103+241c1b6",
-    "@monorepolint/utils": "^0.5.0-alpha.103+241c1b6",
+    "@monorepolint/config": "^0.5.0-alpha.107+27faf77",
+    "@monorepolint/core": "^0.5.0-alpha.107+27faf77",
+    "@monorepolint/utils": "^0.5.0-alpha.107+27faf77",
     "globby": "^13.1.2",
     "jest-diff": "^29.3.1",
     "resolve-package-path": "^4.0.3",
     "runtypes": "^6.6.0",
     "semver": "^7.3.8",
-    "tslib": "^2.3.1"
+    "tslib": "^2.5.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.3.1",
@@ -43,15 +49,15 @@
     "@typescript-eslint/parser": "^5.45.1",
     "eslint": "^8.29.0",
     "jest": "^29.3.1",
-    "prettier": "^2.8.0",
+    "prettier": "^2.8.3",
     "tmp": "^0.2.1",
-    "ts-jest": "^29.0.3",
-    "tslib": "^2.4.1",
+    "ts-jest": "^29.0.5",
+    "tslib": "^2.5.0",
     "tsup": "^6.5.0",
-    "typescript": "^4.9.3"
+    "typescript": "^4.9.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "241c1b6bcf55ee188dd2ee3f652de4c91e0817aa"
+  "gitHead": "27faf7744e0ea03e0609e09747c2c314b56f6e88"
 }