@monorepolint/rules 0.5.0-beta.9 → 0.6.0-alpha.0

package/build/types/index.d.ts

@@ -17,4 +17,5 @@ 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

@@ -1 +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"}
+{"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

@@ -101,101 +101,7 @@ declare const Options: r.Union<[r.Partial<{
     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<{
+export declare const mustSatisfyPeerDependencies: import("./util/createRuleFactory.js").RuleFactoryFn<{
     skipUnparseableRanges?: undefined;
     dependencyWhitelist?: undefined;
     dependencyBlacklist?: undefined;

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

@@ -1 +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"}
+{"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

@@ -6,5 +6,5 @@
  */
 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>;
+export declare const nestedWorkspaces: import("./util/createRuleFactory.js").RuleFactoryFn<unknown>;
 //# 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;AAIH,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAG9B,eAAO,MAAM,OAAO,sBAAc,CAAC;AAKnC,eAAO,MAAM,gBAAgB,sHA0C3B,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,8DA0C3B,CAAC"}

package/build/types/packageEntry.d.ts

@@ -18,26 +18,7 @@ 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: (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<({
+export declare const packageEntry: import("./util/createRuleFactory.js").RuleFactoryFn<({
     entries: {
         [x: string]: unknown;
         [x: number]: unknown;

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

@@ -1 +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"}
+{"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

@@ -4,9 +4,7 @@
  * 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<{
+export declare const packageOrder: import("./util/createRuleFactory.js").RuleFactoryFn<{
     order: string[] | ((...args: any[]) => any);
 } | undefined>;
 //# 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;AAgDH,eAAO,MAAM,YAAY;;;;cAgCvB,CAAC"}
+{"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

@@ -13,22 +13,7 @@ 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: (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<{
+export declare const packageScript: import("./util/createRuleFactory.js").RuleFactoryFn<{
     scripts: {
         [x: string]: string | {
             options: (string | undefined)[];

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

@@ -1 +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"}
+{"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/requireDependency.d.ts

@@ -4,28 +4,7 @@
  * 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<{
+export declare const requireDependency: import("./util/createRuleFactory.js").RuleFactoryFn<{
     dependencies?: {
         [x: string]: string;
         [x: number]: string;

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

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

@@ -24,6 +24,6 @@ declare const Options: r.Constraint<r.Partial<{
 }, 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 declare const standardTsconfig: import("./util/createRuleFactory.js").RuleFactoryFn<Options>;
 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;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"}
+{"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,8DAkC3B,CAAC"}

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

@@ -0,0 +1,14 @@
+import { Context, RuleEntry, RuleModule } from "@monorepolint/config";
+export type ValidateOptionsFn<X> = (options: unknown) => asserts options is X;
+export type RuleFactoryFn<T> = (ruleEntry: RuleEntry<T>) => RuleModule<T>;
+export type RuleCheckFn<O> = (context: Context, options: O, extra: {
+    id: string;
+}) => Promise<unknown> | unknown;
+export interface RuleFactoryOptions<X> {
+    name: string;
+    check: RuleCheckFn<X>;
+    printStats?: () => void;
+    validateOptions: ValidateOptionsFn<X>;
+}
+export declare function createRuleFactory<X>({ name, check, validateOptions, printStats, }: RuleFactoryOptions<X>): RuleFactoryFn<X>;
+//# sourceMappingURL=createRuleFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createRuleFactory.d.ts","sourceRoot":"","sources":["../../../src/util/createRuleFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEtE,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,IAAI,CAAC,CAAC;AAC9E,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC;AAC1E,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAEjH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,eAAe,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;CACvC;AAGD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,EACnC,IAAI,EACJ,KAAK,EACL,eAAe,EACf,UAAU,GACX,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAa1C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monorepolint/rules",
-  "version": "0.5.0-beta.9",
+  "version": "0.6.0-alpha.0",
   "author": "Eric L Anderson (https://github.com/ericanderson)",
   "contributors": [
     "Mac Lockard (https://github.com/maclockard)"
@@ -28,9 +28,9 @@
     "runtypes": "^6.7.0",
     "semver": "^7.6.0",
     "tslib": "^2.6.2",
-    "@monorepolint/config": "^0.5.0-beta.9",
-    "@monorepolint/core": "^0.5.0-beta.9",
-    "@monorepolint/utils": "^0.5.0-beta.9"
+    "@monorepolint/utils": "^0.6.0-alpha.0",
+    "@monorepolint/config": "^0.6.0-alpha.0",
+    "@monorepolint/core": "^0.6.0-alpha.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",

package/src/alphabeticalDependencies.ts

@@ -6,9 +6,9 @@
  */
 
 import { checkAlpha } from "./util/checkAlpha.js";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 
-export const alphabeticalDependencies = makeRule<undefined>({
+export const alphabeticalDependencies = createRuleFactory<undefined>({
   name: "alphabeticalDependencies",
   check: (context) => {
     checkAlpha(context, "dependencies");

package/src/alphabeticalScripts.ts

@@ -6,9 +6,9 @@
  */
 
 import { checkAlpha } from "./util/checkAlpha.js";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 
-export const alphabeticalScripts = makeRule<undefined>({
+export const alphabeticalScripts = createRuleFactory<undefined>({
   name: "alphabeticalScripts",
   check: (context) => {
     checkAlpha(context, "scripts");

package/src/bannedDependencies.ts

@@ -10,7 +10,7 @@ import { matchesAnyGlob } from "@monorepolint/utils";
 import { AggregateTiming } from "@monorepolint/utils";
 import * as path from "node:path";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 import { IPackageDependencyGraphNode, PackageDependencyGraphService } from "./util/packageDependencyGraphService.js";
 // FIXME: This rule is messed. bannedTransitiveDependencies doesnt glob
 
@@ -49,7 +49,7 @@ const setCache = new Map<ReadonlyArray<string>, Set<string>>();
 
 const aggregateTiming = new AggregateTiming(":bannedDependencies stats");
 
-export const bannedDependencies = makeRule<Options>({
+export const bannedDependencies = createRuleFactory<Options>({
   name: "bannedDependencies",
   check: (context, opts, extra) => {
     aggregateTiming.start(extra?.id ?? "unknown id");

package/src/consistentDependencies.ts

@@ -8,7 +8,7 @@
 import { Context } from "@monorepolint/config";
 import { diff } from "jest-diff";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 const Options = r
   .Record({
     ignoredDependencies: r.Array(r.String).Or(r.Undefined),
@@ -18,7 +18,7 @@ export type Options = r.Static<typeof Options>;
 
 const skippedVersions = ["*", "latest"];
 
-export const consistentDependencies = makeRule<Options>({
+export const consistentDependencies = createRuleFactory<Options>({
   name: "consistentDependencies",
   check: (context, args) => {
     checkDeps(context, args, "dependencies");

package/src/consistentVersions.ts

@@ -9,14 +9,14 @@ import { Context } from "@monorepolint/config";
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import * as r from "runtypes";
 import { coerce, SemVer } from "semver";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 export const Options = r.Record({
   matchDependencyVersions: r.Dictionary(r.Union(r.String, r.Array(r.String))),
 });
 
 export type Options = r.Static<typeof Options>;
 
-export const consistentVersions = makeRule({
+export const consistentVersions = createRuleFactory({
   name: "consistentVersions",
   check: checkConsistentVersions,
   validateOptions: Options.check,

package/src/fileContents.ts

@@ -9,7 +9,7 @@ import { Context } from "@monorepolint/config";
 import { diff } from "jest-diff";
 import * as path from "path";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 const Options = r.Union(
   r.Record({
     file: r.String,
@@ -35,7 +35,7 @@ const Options = r.Union(
 
 type Options = r.Static<typeof Options>;
 
-export const fileContents = makeRule<Options>({
+export const fileContents = createRuleFactory<Options>({
   name: "fileContents",
   check: async (context, opts) => {
     const fullPath = path.join(context.packageDir, opts.file);

package/src/index.ts

@@ -18,3 +18,11 @@ 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";

package/src/mustSatisfyPeerDependencies.ts

@@ -11,7 +11,7 @@ import * as path from "node:path";
 import * as r from "runtypes";
 import { coerce } from "semver";
 import resolvePackagePath from "resolve-package-path";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 
 const Options = r.Union(
   r.Partial({
@@ -184,7 +184,7 @@ const Options = r.Union(
 
 export type Options = r.Static<typeof Options>;
 
-export const mustSatisfyPeerDependencies = makeRule({
+export const mustSatisfyPeerDependencies = createRuleFactory({
   name: "mustSatisfyPeerDependencies",
   check: checkSatisfyPeerDependencies,
   validateOptions: Options.check,

package/src/nestedWorkspaces.ts

@@ -8,14 +8,14 @@
 import * as globby from "globby";
 import * as path from "node:path";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 
 export const Options = r.Undefined;
 
 type Options = r.Static<typeof Options>;
 
 // Enforce that the root package.json contains all of the workspaces in the repo (including nested packages)
-export const nestedWorkspaces = makeRule({
+export const nestedWorkspaces = createRuleFactory({
   name: "nestedWorkspaces",
   check: (context) => {
     const rootPackageJson = context.getWorkspaceContext().getPackageJson();
@@ -26,8 +26,8 @@ export const nestedWorkspaces = makeRule({
     const workspaces = Array.isArray(rootPackageJson.workspaces)
       ? rootPackageJson.workspaces
       : rootPackageJson.workspaces !== undefined
-      ? rootPackageJson.workspaces.packages
-      : undefined;
+        ? rootPackageJson.workspaces.packages
+        : undefined;
 
     if (workspaces === undefined && packageJsonPaths.length > 0) {
       context.addError({

package/src/packageEntry.ts

@@ -8,7 +8,7 @@
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import { diff } from "jest-diff";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 
 export const Options = r.Union(
   r
@@ -37,7 +37,7 @@ export const Options = r.Union(
 
 export type Options = r.Static<typeof Options>;
 
-export const packageEntry = makeRule<Options>({
+export const packageEntry = createRuleFactory<Options>({
   name: "packageEntry",
   check: (context, options) => {
     const packageJson = context.getPackageJson();

package/src/packageOrder.ts

@@ -8,7 +8,7 @@
 import { Context } from "@monorepolint/config";
 import { diff } from "jest-diff";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 type OrderFunction = (context: Context) => (a: string, b: string) => number;
 
 const Options = r
@@ -51,7 +51,7 @@ const defaultKeyOrder = [
   "publishConfig",
 ];
 
-export const packageOrder = makeRule<Options>({
+export const packageOrder = createRuleFactory<Options>({
   name: "packageOrder",
   check: (context, opts) => {
     const packageJson = context.getPackageJson();

package/src/packageScript.ts

@@ -8,7 +8,7 @@
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import { diff } from "jest-diff";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 
 export const Options = r.Record({
   scripts: r.Dictionary(
@@ -26,7 +26,7 @@ export type Options = r.Static<typeof Options>;
 
 export const MSG_NO_SCRIPTS_BLOCK = "No scripts block in package.json";
 
-export const packageScript = makeRule<Options>({
+export const packageScript = createRuleFactory<Options>({
   name: "packageScript",
   check: (context, options) => {
     const packageJson = context.getPackageJson();

package/src/requireDependency.ts

@@ -9,7 +9,7 @@ import { Context } from "@monorepolint/config";
 import { mutateJson, PackageJson } from "@monorepolint/utils";
 import { diff } from "jest-diff";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 
 const Options = r.Partial({
   dependencies: r.Dictionary(r.String),
@@ -20,7 +20,7 @@ const Options = r.Partial({
 
 type Options = r.Static<typeof Options>;
 
-export const requireDependency = makeRule({
+export const requireDependency = createRuleFactory({
   name: "requireDependency",
   check: function expectPackageEntry(context: Context, options: Options) {
     const packageJson = context.getPackageJson();

package/src/standardTsconfig.ts

@@ -10,7 +10,7 @@ import { matchesAnyGlob } from "@monorepolint/utils";
 import { diff } from "jest-diff";
 import * as path from "path";
 import * as r from "runtypes";
-import { makeRule } from "./util/makeRule.js";
+import { createRuleFactory } from "./util/createRuleFactory.js";
 
 const DEFAULT_TSCONFIG_FILENAME = "tsconfig.json";
 
@@ -41,7 +41,7 @@ const Options = r
 
 export interface Options extends r.Static<typeof Options> {}
 
-export const standardTsconfig = makeRule<Options>({
+export const standardTsconfig = createRuleFactory<Options>({
   name: "standardTsconfig",
   check: async (context, opts) => {
     const tsconfigFileName = opts.file ?? DEFAULT_TSCONFIG_FILENAME;

package/src/util/createRuleFactory.ts

@@ -0,0 +1,33 @@
+import { Context, RuleEntry, RuleModule } from "@monorepolint/config";
+
+export type ValidateOptionsFn<X> = (options: unknown) => asserts options is X;
+export type RuleFactoryFn<T> = (ruleEntry: RuleEntry<T>) => RuleModule<T>;
+export type RuleCheckFn<O> = (context: Context, options: O, extra: { id: string }) => Promise<unknown> | unknown;
+
+export interface RuleFactoryOptions<X> {
+  name: string;
+  check: RuleCheckFn<X>;
+  printStats?: () => void;
+  validateOptions: ValidateOptionsFn<X>;
+}
+
+let globalId = 0;
+export function createRuleFactory<X>({
+  name,
+  check,
+  validateOptions,
+  printStats,
+}: RuleFactoryOptions<X>): RuleFactoryFn<X> {
+  return function (ruleEntry) {
+    const id = ruleEntry.id ?? `${name} :: ${globalId++}`;
+    return {
+      id,
+      // eslint-disable-next-line @typescript-eslint/no-extra-non-null-assertion
+      check: (context) => check(context, ruleEntry.options!!, { id }),
+      name,
+      validateOptions,
+      ruleEntry,
+      printStats,
+    };
+  };
+}

package/build/js/chunk-A2MUUSNE.js

@@ -1,26 +0,0 @@
-// src/util/makeRule.ts
-var globalId = 0;
-function makeRule({
-  name,
-  check,
-  validateOptions,
-  printStats
-}) {
-  return function(ruleEntry) {
-    const id = `${name} :: ${globalId++}`;
-    return {
-      id,
-      // eslint-disable-next-line @typescript-eslint/no-extra-non-null-assertion
-      check: (context) => check(context, ruleEntry.options, { id }),
-      name,
-      validateOptions,
-      ruleEntry,
-      printStats
-    };
-  };
-}
-
-export {
-  makeRule
-};
-//# sourceMappingURL=chunk-A2MUUSNE.js.map

package/build/js/chunk-A2MUUSNE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/util/makeRule.ts"],"sourcesContent":["import { Context, RuleEntry, RuleModule } from \"@monorepolint/config\";\n\nlet globalId = 0;\nexport function makeRule<X>({\n  name,\n  check,\n  validateOptions,\n  printStats,\n}: {\n  name: string;\n  check: (context: Context, options: X, extra: { id: string }) => Promise<unknown> | unknown;\n  printStats?: () => void;\n  validateOptions: (options: unknown) => asserts options is X;\n}): RuleFunction<X> {\n  return function (ruleEntry) {\n    const id = `${name} :: ${globalId++}`;\n    return {\n      id,\n      // eslint-disable-next-line @typescript-eslint/no-extra-non-null-assertion\n      check: (context) => check(context, ruleEntry.options!!, { id }),\n      name,\n      validateOptions,\n      ruleEntry,\n      printStats,\n    };\n  };\n}\n\ntype RuleFunction<T> = (ruleEntry: RuleEntry<T>) => RuleModule<T>;\n"],"mappings":";AAEA,IAAI,WAAW;AACR,SAAS,SAAY;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAKoB;AAClB,SAAO,SAAU,WAAW;AAC1B,UAAM,KAAK,GAAG,IAAI,OAAO,UAAU;AACnC,WAAO;AAAA,MACL;AAAA;AAAA,MAEA,OAAO,CAAC,YAAY,MAAM,SAAS,UAAU,SAAW,EAAE,GAAG,CAAC;AAAA,MAC9D;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;","names":[]}