deep-guards 1.0.0

package/.yarn.yml

@@ -0,0 +1,11 @@
+nodeLinker: node-modules
+
+plugins:
+  - path: .yarn/plugins/@yarnpkg/plugin-workspace-tools.cjs
+    spec: "@yarnpkg/plugin-workspace-tools"
+  - path: .yarn/plugins/@yarnpkg/plugin-typescript.cjs
+    spec: "@yarnpkg/plugin-typescript"
+  - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
+    spec: "@yarnpkg/plugin-version"
+
+yarnPath: .yarn/releases/yarn-3.8.2.cjs

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,167 @@
+# Deep-Guards
+
+This solves the cases where you have a nested JSON data structure, and are wanting to guard the whole structure in one go, rather than doing shallow guards.
+
+I was also surprised that there's not too many options for guarding things with type narrowing in the case of discriminated unions. This library also solves that!
+
+I have also oriented this library towards making the type tooltips as descriptive as possible.
+
+Example use case:
+
+```ts
+const carGuard = isObjectOf({
+  type: isExact("car"),
+  wheels: isExact(4),
+  owner: isString,
+  passengers: isArrayOf(
+    isObjectOf({
+      name: isString,
+    })
+  ),
+});
+
+const bikeGuard = isObjectOf({
+  type: isExact("bike"),
+  wheels: isExact(2),
+  owner: isString,
+  storage: isOptional(isArrayOf(isString)),
+});
+
+const vehicleGuard = isUnionOf(carGuard, bikeGuard);
+
+const value: unknown = { ... };
+
+if (vehicleGuard(value)) {
+  value.wheels;
+
+  if (value.type === "car") {
+    // value is a Car
+  } else {
+    // value is a bike
+  }
+}
+```
+
+## Contents
+
+1. [Primitives](#primitives)
+2. [Compound](#compound)
+   1. [isOptional](#isoptional)
+   2. [isNullable](#isnullable)
+   3. [isNonNullable](#isnonnullable)
+   4. [isNot](#isnot)
+   5. [isOneOf](#isoneof)
+   6. [isUnionOf](#isunionof)
+   7. [isExact](#isexact)
+3. [Structures](#structures)
+   1. [isAnyArray](#isanyarray)
+   2. [isAnyRecord](#isanyrecord)
+   3. [isArrayOf](#isarrayof)
+   4. [isRecordOf](#isrecordof)
+   5. [isObjectOf](#isobjectof)
+
+## Terminology
+
+- Guard:
+  - A function which lets you narrow down an incoming `unknown` value type, into a defined type.
+- Simple guard:
+  - A variable which is set to a Guard
+- Higher order guard:
+  - This is a function which takes in a guard function as a parameter, and then will produce a new guard function as a result.
+- Incoming value:
+  - The value being guarded against.
+
+## Primitives
+
+There's all the usual suspects for primitives. They are all simple guards.
+
+The full list of available primitive guards is below:
+
+- isUnknown
+- isNull
+- isUndefined
+- isNumber
+- isInteger
+- isString
+- isSymbol
+- isBoolean
+- isFunction
+
+## Compound
+
+There's also compound guards, which do more complex checks than the primitives:
+
+### isOptional
+
+Higher order guard. This lets the incoming value to also be equal to `undefined` as well.
+
+### isNullable
+
+Higher order guard. This lets the incoming value to also be equal to `null` or `undefined` as well.
+
+### isNonNullable
+
+Simple guard. This will extract `null` and `undefined` from the incoming value type.
+
+### isNot
+
+Higher order guard. This will do the inverse of the incoming guard.
+
+### isOneOf
+
+Has signature:
+
+```ts
+function isOneOf<
+  const T extends (string | number | boolean | symbol | null | undefined)[]
+>(...values: T): Guard<(typeof values)[number]>;
+```
+
+It's very useful for enumerations, where you only have a few specific values, e.g. a status enum with a guard: `isOneOf("active", "inactive", "away")`. When using the enum, it will then be narrowed down to those specific values, so in the case of the example, a value will be narrowed down to the type: `"active" | "inactive" | "away"`.
+
+### isUnionOf
+
+Higher order guard. This takes in any amount of guards as arguments, and then produces a guard which does a union over all the incoming guards.
+
+### isExact
+
+Has signature:
+
+```ts
+function isExact<const T>(expected: T, deep: boolean = true): Guard<T>;
+```
+
+This will pass if the incoming value exactly matches the `expected` parameter, optionally computing a deep equality.
+
+## Structures
+
+Finally there's structure guards, which guard against things like objects/arrays/records.
+
+### isAnyArray
+
+Simple guard. Passes if the incoming value is an array.
+
+### isAnyRecord
+
+Simple guard. Passes if the incoming value is an object/record, but **not** if it's an array.
+
+### isArrayOf
+
+Higher order guard. This will pass if the incoming value is an array which contains elements which are of the type of the passed in guard function.
+
+NOTE: This passes for empty arrays
+
+### isRecordOf
+
+Higher order guard. It has two guard parameters, where the first is the key guard, and then the second is a value guard which is optional. If you don't pass in a value guard, the returned guard function has `unknown`s as the value type.
+
+NOTE: This passes for empty records
+
+### isObjectOf
+
+This is a function which takes in a structured object, containing keys of type `string | number | symbol`, and then values which are guard functions.
+
+As seen in the example at the start of this readme, you can do all sorts of complex nesting, as this produces a guard in the end.
+
+NOTE: This throws an error if you give it an empty object.\
+It will also accept an object which contains keys which are not specified.

package/babel.config.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  presets: [
+    ["@babel/preset-env", { targets: { node: "current" } }],
+    "@babel/preset-typescript",
+  ],
+};

package/dist/compound.d.ts

@@ -0,0 +1,8 @@
+import { Guard, GuardSchemaOf } from "./types.js";
+export declare function isOptional<T>(guard: Guard<T>): Guard<T | undefined>;
+export declare function isNullable<T>(guard: Guard<T>): Guard<T | null | undefined>;
+export declare function isNonNullable<T>(value: T | null | undefined): value is T;
+export declare function isNot<const N>(guard: Guard<N>): <const T>(value: T | N) => value is T;
+export declare function isOneOf<const T extends (string | number | boolean | symbol | null | undefined)[]>(...values: T): Guard<(typeof values)[number]>;
+export declare function isUnionOf<T extends readonly unknown[]>(...guards: GuardSchemaOf<T>): Guard<T[number]>;
+export declare function isExact<const T>(expected: T, deep?: boolean): Guard<T>;

package/dist/compound.js

@@ -0,0 +1,48 @@
+export function isOptional(guard) {
+    if (typeof guard !== "function") {
+        throw new TypeError(`isOptional expects a guard parameter. Got instead: ${guard}`);
+    }
+    return ((value) => value === undefined || guard(value));
+}
+export function isNullable(guard) {
+    if (typeof guard !== "function") {
+        throw new TypeError(`isNullable expects a guard parameter. Got instead: ${guard}`);
+    }
+    return (value) => value == null || guard(value);
+}
+export function isNonNullable(value) {
+    return value != null;
+}
+export function isNot(guard) {
+    if (typeof guard !== "function") {
+        throw new TypeError(`isNot expects a guard parameter. Got instead: ${guard}`);
+    }
+    return (value) => !guard(value);
+}
+export function isOneOf(...values) {
+    const valueSet = new Set(values);
+    return (value) => valueSet.has(value);
+}
+export function isUnionOf(...guards) {
+    if (guards.every((guard) => typeof guard !== "function")) {
+        throw new TypeError(`isUnionOf expects N guard parameters. Got instead: ${guards}`);
+    }
+    return (value) => guards.some((guard) => guard(value));
+}
+function isEqual(a, b) {
+    return (a === b ||
+        (a != null &&
+            b != null &&
+            typeof a === "object" &&
+            typeof b === "object" &&
+            (Array.isArray(a)
+                ? Array.isArray(b) &&
+                    a.length === b.length &&
+                    a.every((v, i) => isEqual(v, b[i]))
+                : Object.keys(a).length === Object.keys(b).length &&
+                    Object.entries(a).every(([k, v]) => k in b && isEqual(v, b[k])))));
+}
+export function isExact(expected, deep = true) {
+    return (value) => deep ? isEqual(expected, value) : expected === value;
+}
+//# sourceMappingURL=compound.js.map

package/dist/compound.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compound.js","sourceRoot":"src/","sources":["compound.ts"],"names":[],"mappings":"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"}

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+import { Guard } from "./types.js";
+export declare class GuardError extends Error {
+    name: string;
+}
+export declare function guardOrThrow<T>(value: unknown, guard: Guard<T>, hint?: string): T;

package/dist/errors.js

@@ -0,0 +1,12 @@
+export class GuardError extends Error {
+    name = "GuardError";
+}
+export function guardOrThrow(value, guard, hint) {
+    if (guard(value)) {
+        return value;
+    }
+    else {
+        throw new GuardError(hint ?? "Guard error");
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"src/","sources":["errors.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,UAAW,SAAQ,KAAK;IACnC,IAAI,GAAG,YAAY,CAAC;CACrB;AAED,MAAM,UAAU,YAAY,CAC1B,KAAc,EACd,KAAe,EACf,IAAa;IAEb,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO,KAAK,CAAC;IACf,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,UAAU,CAAC,IAAI,IAAI,aAAa,CAAC,CAAC;IAC9C,CAAC;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./compound.js";
+export * from "./errors.js";
+export * from "./primitives.js";
+export * from "./structures.js";
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./compound.js";
+export * from "./errors.js";
+export * from "./primitives.js";
+export * from "./structures.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"src/","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC"}

package/dist/primitives.d.ts

@@ -0,0 +1,10 @@
+import { Guard } from "./types.js";
+export declare const isUnknown: Guard<unknown>;
+export declare const isNull: Guard<null>;
+export declare const isUndefined: Guard<undefined>;
+export declare const isNumber: Guard<number>;
+export declare const isInteger: Guard<number>;
+export declare const isString: Guard<string>;
+export declare const isSymbol: Guard<symbol>;
+export declare const isBoolean: Guard<boolean>;
+export declare const isFunction: Guard<(...args: unknown[]) => unknown>;

package/dist/primitives.js

@@ -0,0 +1,10 @@
+export const isUnknown = (_value) => true;
+export const isNull = (value) => value === null;
+export const isUndefined = (value) => value === undefined;
+export const isNumber = (value) => typeof value === "number";
+export const isInteger = (value) => Number.isInteger(value);
+export const isString = (value) => typeof value === "string";
+export const isSymbol = (value) => typeof value === "symbol";
+export const isBoolean = (value) => value === true || value === false;
+export const isFunction = (value) => typeof value === "function";
+//# sourceMappingURL=primitives.js.map

package/dist/primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.js","sourceRoot":"src/","sources":["primitives.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAmB,CAAC,MAAM,EAAqB,EAAE,CAAC,IAAI,CAAC;AAE7E,MAAM,CAAC,MAAM,MAAM,GAAgB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC;AAE7D,MAAM,CAAC,MAAM,WAAW,GAAqB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC;AAE5E,MAAM,CAAC,MAAM,QAAQ,GAAkB,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;AAE5E,MAAM,CAAC,MAAM,SAAS,GAAkB,CAAC,KAAK,EAAmB,EAAE,CACjE,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AAE1B,MAAM,CAAC,MAAM,QAAQ,GAAkB,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;AAE5E,MAAM,CAAC,MAAM,QAAQ,GAAkB,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;AAE5E,MAAM,CAAC,MAAM,SAAS,GAAmB,CAAC,KAAK,EAAE,EAAE,CACjD,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,KAAK,CAAC;AAEpC,MAAM,CAAC,MAAM,UAAU,GAA2C,CAChE,KAAK,EACqC,EAAE,CAAC,OAAO,KAAK,KAAK,UAAU,CAAC"}

package/dist/structures.d.ts

@@ -0,0 +1,9 @@
+import { Guard, GuardSchemaOf } from "./types.js";
+type ObjectKey = string | number | symbol;
+export declare const isAnyArray: Guard<unknown[]>;
+export declare const isAnyRecord: Guard<Record<ObjectKey, unknown>>;
+export declare function isArrayOf<T>(guard: Guard<T>): Guard<T[]>;
+export declare function isRecordOf<K extends ObjectKey>(keyGuard: Guard<K>): Guard<Record<K, unknown>>;
+export declare function isRecordOf<K extends ObjectKey, V>(keyGuard: Guard<K>, valueGuard: Guard<V>): Guard<Record<K, V>>;
+export declare function isObjectOf<O extends object>(schema: GuardSchemaOf<O>): O extends unknown[] ? never : Guard<O>;
+export {};

package/dist/structures.js

@@ -0,0 +1,41 @@
+function objectKeys(obj) {
+    return Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertySymbols(obj));
+}
+export const isAnyArray = value => Array.isArray(value);
+export const isAnyRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+export function isArrayOf(guard) {
+    if (typeof guard !== "function") {
+        throw new TypeError(`isArrayOf expects a guard parameter. Got instead: ${guard}`);
+    }
+    return (value) => Array.isArray(value) && value.every(guard);
+}
+export function isRecordOf(keyGuard, valueGuard) {
+    if (typeof keyGuard !== "function") {
+        throw new TypeError(`isRecordOf keyGuard expects a guard parameter. Got instead: ${keyGuard}`);
+    }
+    else if (valueGuard != null && typeof valueGuard !== "function") {
+        throw new TypeError(`isRecordOf valueGuard expects an optional guard parameter. Got instead: ${valueGuard}`);
+    }
+    return (value) => value != null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        objectKeys(value).every(key => keyGuard(key) && (valueGuard?.(value[key]) ?? true));
+}
+export function isObjectOf(schema) {
+    const schemaKeys = objectKeys(schema);
+    const schemaUnknown = schema;
+    if (schemaKeys.length === 0) {
+        throw new Error("isObjectOf received an empty schema");
+    }
+    else if (schemaUnknown == null ||
+        typeof schemaUnknown !== "object" ||
+        Array.isArray(schemaUnknown) ||
+        schemaKeys.some(key => typeof schemaUnknown[key] !== "function")) {
+        throw new TypeError(`isObjectOf expects a guard schema. Got instead: ${schemaUnknown}`);
+    }
+    return ((value) => value != null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        schemaKeys.every(key => key in value && schema[key](value[key])));
+}
+//# sourceMappingURL=structures.js.map

package/dist/structures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structures.js","sourceRoot":"src/","sources":["structures.ts"],"names":[],"mappings":"AAIA,SAAS,UAAU,CAAsB,GAAuB;IAC9D,OAAQ,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAS,CAAC,MAAM,CACpD,MAAM,CAAC,qBAAqB,CAAC,GAAG,CAAQ,CACzC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,UAAU,GAAqB,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAE1E,MAAM,CAAC,MAAM,WAAW,GAAsC,CAC5D,KAAK,EACgC,EAAE,CACvC,KAAK,IAAI,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAEtE,MAAM,UAAU,SAAS,CAAI,KAAe;IAC1C,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;QAChC,MAAM,IAAI,SAAS,CACjB,qDAAqD,KAAK,EAAE,CAC7D,CAAC;IACJ,CAAC;IAED,OAAO,CAAC,KAAK,EAAgB,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC7E,CAAC;AASD,MAAM,UAAU,UAAU,CACxB,QAAkB,EAClB,UAAqB;IAErB,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;QACnC,MAAM,IAAI,SAAS,CACjB,+DAA+D,QAAQ,EAAE,CAC1E,CAAC;IACJ,CAAC;SAAM,IAAI,UAAU,IAAI,IAAI,IAAI,OAAO,UAAU,KAAK,UAAU,EAAE,CAAC;QAClE,MAAM,IAAI,SAAS,CACjB,2EAA2E,UAAU,EAAE,CACxF,CAAC;IACJ,CAAC;IAED,OAAO,CAAC,KAAK,EAAyB,EAAE,CACtC,KAAK,IAAI,IAAI;QACb,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACrB,UAAU,CAAC,KAAK,CAAC,CAAC,KAAK,CACrB,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAC3D,CAAC;AACN,CAAC;AAED,MAAM,UAAU,UAAU,CACxB,MAAwB;IAExB,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,aAAa,GAAG,MAAiB,CAAC;IACxC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACzD,CAAC;SAAM,IACL,aAAa,IAAI,IAAI;QACrB,OAAO,aAAa,KAAK,QAAQ;QACjC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC;QAC5B,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,OAAQ,aAAmB,CAAC,GAAG,CAAC,KAAK,UAAU,CAAC,EACvE,CAAC;QACD,MAAM,IAAI,SAAS,CACjB,mDAAmD,aAAa,EAAE,CACnE,CAAC;IACJ,CAAC;IAED,OAAO,CAAC,CAAC,KAAK,EAAc,EAAE,CAC5B,KAAK,IAAI,IAAI;QACb,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACrB,UAAU,CAAC,KAAK,CACd,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,KAAK,IAAI,MAAM,CAAC,GAAG,CAAC,CAAE,KAAW,CAAC,GAAG,CAAC,CAAC,CACtD,CAA2C,CAAC;AACjD,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export type Guard<T> = (value: unknown) => value is T;
+export type GuardSchemaOf<O extends object> = {
+    [K in keyof O]: Guard<O[K]>;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"src/","sources":["types.ts"],"names":[],"mappings":""}

package/eslint.config.js

@@ -0,0 +1,51 @@
+import typescriptParser from "@typescript-eslint/parser";
+import jslint from "@eslint/js";
+import tslint from "typescript-eslint";
+import tsPlugin from "@typescript-eslint/eslint-plugin";
+
+export default tslint.config(
+  jslint.configs.recommended,
+  ...tslint.configs.recommended,
+  ...tslint.configs.recommendedTypeChecked,
+  ...tslint.configs.strictTypeChecked,
+  {
+    languageOptions: {
+      parser: typescriptParser,
+      parserOptions: { project: "./tsconfig.json" },
+    },
+
+    plugins: { tsPlugin },
+
+    rules: {
+      // CORE
+      // According to https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/indent.md
+      // the default indentation rule can cause eslint to report erroneous style errors.
+      indent: "off",
+      "no-console": "off",
+      eqeqeq: ["warn", "smart"],
+      "require-yield": "off",
+      "prettier/prettier": "off",
+      // "eslint-comments/disable-enable-pair": ["warn", { allowWholeFile: true }],
+      // TYPESCRIPT
+      "@typescript-eslint/prefer-reduce-type-parameter": "off",
+      // We use ts-ignore because we want to suppress type errors... don't warn us about it, please
+      "@typescript-eslint/ban-ts-comment": "off",
+      // We don't want to specify the return type everywhere as we get the type safety without it
+      "@typescript-eslint/explicit-function-return-type": "off",
+      // We don't want to have to specify accessibility modifiers on every method, but they are part of
+      // the "recommended" config. This turns it off. Rational: https://github.com/typescript-eslint/typescript-eslint/issues/201
+      "@typescript-eslint/explicit-member-accessibility": "off",
+      "@typescript-eslint/restrict-template-expressions": "off",
+      // Use prettier for indentation, not typescript-eslint:
+      "@typescript-eslint/indent": "off",
+      // We want to only warn about empty interfaces as they might just be placeholders for the future
+      "@typescript-eslint/no-empty-interface": "off",
+      "@typescript-eslint/no-empty-function": "warn",
+      "@typescript-eslint/no-inferrable-types": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        { varsIgnorePattern: "^_", argsIgnorePattern: "^_" },
+      ],
+    },
+  }
+);