@infra-blocks/types 0.28.0 → 0.29.0

package/lib/cjs/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./func.js";
 export * from "./guard.js";
+export * from "./keys.js";
 export * from "./predicates.js";
 export * from "./types.js";
 /**

package/lib/cjs/index.js

@@ -19,6 +19,7 @@ exports.trusted = trusted;
 const node_assert_1 = require("node:assert");
 __exportStar(require("./func.js"), exports);
 __exportStar(require("./guard.js"), exports);
+__exportStar(require("./keys.js"), exports);
 __exportStar(require("./predicates.js"), exports);
 __exportStar(require("./types.js"), exports);
 // TODO: Message type, that is either: undefined, a string, a string followed by format args or a function returning a string.

package/lib/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AA+BA,kCAEC;AAsBD,0BAEC;AAzDD,6CAAmC;AAEnC,4CAA0B;AAC1B,6CAA2B;AAC3B,kDAAgC;AAChC,6CAA2B;AAE3B,8HAA8H;AAC9H;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,WAAW,CAAC,CAAQ,EAAE,OAAgB;IACpD,IAAA,kBAAI,EAAC,OAAO,IAAI,2BAA2B,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,OAAO,CAAI,KAAc;IACvC,OAAO,KAAU,CAAC;AACpB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAgCA,kCAEC;AAsBD,0BAEC;AA1DD,6CAAmC;AAEnC,4CAA0B;AAC1B,6CAA2B;AAC3B,4CAA0B;AAC1B,kDAAgC;AAChC,6CAA2B;AAE3B,8HAA8H;AAC9H;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,WAAW,CAAC,CAAQ,EAAE,OAAgB;IACpD,IAAA,kBAAI,EAAC,OAAO,IAAI,2BAA2B,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,OAAO,CAAI,KAAc;IACvC,OAAO,KAAU,CAAC;AACpB,CAAC"}

package/lib/cjs/keys.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A convenience type mapping to extract keys of a type that extend a given type.
+ *
+ * For example, if you would like all the types of an object that are numbers, you could do
+ * `KeysOfType<TheType, number>`.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/34992
+ */
+export type ExtendingKeys<T, U> = keyof {
+    [P in keyof T as T[P] extends U ? P : never]: P;
+};
+/**
+ * A mapped type remapping all keys of K to type V.
+ */
+export type MapKeys<K, V> = {
+    [k in keyof K]: V;
+};
+/**
+ * A type utility useful to constrain types to have the same keys as M, without imposing
+ * restrictions on the value.
+ *
+ * It's an alias for MapKeys<M, unknown>.
+ */
+export type SameKeys<M> = MapKeys<M, unknown>;

package/lib/cjs/keys.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * A convenience type mapping to extract keys of a type that extend a given type.
+ *
+ * For example, if you would like all the types of an object that are numbers, you could do
+ * `KeysOfType<TheType, number>`.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/34992
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=keys.js.map

package/lib/cjs/keys.js.map

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

package/lib/cjs/types.d.ts

@@ -31,33 +31,12 @@ export type EnvironmentVariables = Record<string, string | undefined>;
  * Just aliasing {@link EnvironmentVariables} for brevity.
  */
 export type EnvVars = EnvironmentVariables;
-/**
- * A convenience type mapping to extract keys of a type that are of a given type.
- *
- * For example, if you would like all the types of an object that are numbers, you could do
- * KeyOfType<TheType, number>
- */
-export type KeyOfType<T, U> = {
-    [P in keyof T]: T[P] extends U ? P : never;
-}[keyof T];
-/**
- * A mapped type remapping all keys of K to type V.
- */
-export type MapKeys<K, V> = {
-    [k in keyof K]: V;
-};
 /**
  * Convenient type alias to regroup a type that can be T, null or undefined.
  *
  * Semantically the opposite of {@link NonNullable}.
  */
 export type Nullable<T> = T | null | undefined;
-/**
- * Convenient mapped type to selectively make some fields of a type optional.
- *
- * This is in contrast to the built-in `Partial` type which makes all fields optional.
- */
-export type Optional<T, K extends keyof T = keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
 /**
  * A utility type for tracking a phantom type parameter.
  */
@@ -68,13 +47,6 @@ export type Phantom<T> = {
  * A union type that includes all primitive types.
  */
 export type Primitive = bigint | boolean | null | number | string | symbol | undefined;
-/**
- * A type utility useful to constrain types to have the same keys as M, without imposing
- * restrictions on the value.
- *
- * It's an alias for MapKeys<M, unknown>.
- */
-export type SameKeys<M> = MapKeys<M, unknown>;
 /**
  * A type representing all types that can be used in a vanilla template literal.
  *

package/lib/esm/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./func.js";
 export * from "./guard.js";
+export * from "./keys.js";
 export * from "./predicates.js";
 export * from "./types.js";
 /**

package/lib/esm/index.js

@@ -1,6 +1,7 @@
 import { fail } from "node:assert";
 export * from "./func.js";
 export * from "./guard.js";
+export * from "./keys.js";
 export * from "./predicates.js";
 export * from "./types.js";
 // TODO: Message type, that is either: undefined, a string, a string followed by format args or a function returning a string.

package/lib/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAE3B,8HAA8H;AAC9H;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,WAAW,CAAC,CAAQ,EAAE,OAAgB;IACpD,IAAI,CAAC,OAAO,IAAI,2BAA2B,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,OAAO,CAAI,KAAc;IACvC,OAAO,KAAU,CAAC;AACpB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAE3B,8HAA8H;AAC9H;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,WAAW,CAAC,CAAQ,EAAE,OAAgB;IACpD,IAAI,CAAC,OAAO,IAAI,2BAA2B,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,OAAO,CAAI,KAAc;IACvC,OAAO,KAAU,CAAC;AACpB,CAAC"}

package/lib/esm/keys.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A convenience type mapping to extract keys of a type that extend a given type.
+ *
+ * For example, if you would like all the types of an object that are numbers, you could do
+ * `KeysOfType<TheType, number>`.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/34992
+ */
+export type ExtendingKeys<T, U> = keyof {
+    [P in keyof T as T[P] extends U ? P : never]: P;
+};
+/**
+ * A mapped type remapping all keys of K to type V.
+ */
+export type MapKeys<K, V> = {
+    [k in keyof K]: V;
+};
+/**
+ * A type utility useful to constrain types to have the same keys as M, without imposing
+ * restrictions on the value.
+ *
+ * It's an alias for MapKeys<M, unknown>.
+ */
+export type SameKeys<M> = MapKeys<M, unknown>;

package/lib/esm/keys.js

@@ -0,0 +1,10 @@
+/**
+ * A convenience type mapping to extract keys of a type that extend a given type.
+ *
+ * For example, if you would like all the types of an object that are numbers, you could do
+ * `KeysOfType<TheType, number>`.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/34992
+ */
+export {};
+//# sourceMappingURL=keys.js.map

package/lib/esm/keys.js.map

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

package/lib/esm/types.d.ts

@@ -31,33 +31,12 @@ export type EnvironmentVariables = Record<string, string | undefined>;
  * Just aliasing {@link EnvironmentVariables} for brevity.
  */
 export type EnvVars = EnvironmentVariables;
-/**
- * A convenience type mapping to extract keys of a type that are of a given type.
- *
- * For example, if you would like all the types of an object that are numbers, you could do
- * KeyOfType<TheType, number>
- */
-export type KeyOfType<T, U> = {
-    [P in keyof T]: T[P] extends U ? P : never;
-}[keyof T];
-/**
- * A mapped type remapping all keys of K to type V.
- */
-export type MapKeys<K, V> = {
-    [k in keyof K]: V;
-};
 /**
  * Convenient type alias to regroup a type that can be T, null or undefined.
  *
  * Semantically the opposite of {@link NonNullable}.
  */
 export type Nullable<T> = T | null | undefined;
-/**
- * Convenient mapped type to selectively make some fields of a type optional.
- *
- * This is in contrast to the built-in `Partial` type which makes all fields optional.
- */
-export type Optional<T, K extends keyof T = keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
 /**
  * A utility type for tracking a phantom type parameter.
  */
@@ -68,13 +47,6 @@ export type Phantom<T> = {
  * A union type that includes all primitive types.
  */
 export type Primitive = bigint | boolean | null | number | string | symbol | undefined;
-/**
- * A type utility useful to constrain types to have the same keys as M, without imposing
- * restrictions on the value.
- *
- * It's an alias for MapKeys<M, unknown>.
- */
-export type SameKeys<M> = MapKeys<M, unknown>;
 /**
  * A type representing all types that can be used in a vanilla template literal.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infra-blocks/types",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Typescript types utility package.",
   "keywords": [
     "type",
@@ -44,7 +44,6 @@
     "@typescript-eslint/eslint-plugin": "^5.59.8",
     "@typescript-eslint/parser": "^5.59.8",
     "c8": "^8.0.0",
-    "expect-type": "^1.3.0",
     "lefthook": "^2.0.8",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"