@ptolemy2002/ts-utils 2.3.0 → 2.5.0

package/README.md

@@ -70,6 +70,42 @@ type AdvancedConditionConstructorArgs<T> = {
 ### ValuesIntersection<T>
 This type returns an intersection of all the possible values in an object of type `T`.
 
+### Contains<L extends unknown[], T>
+This type returns a boolean indicating whether the type `T` is contained in the array `L`.
+
+### BrandTag<B extends unknown[]>
+This type returns a record with a single key of type `__brand` and a value of type `B`. It represents a brand that can be used to differentiate between types.
+
+Branded types are useful for making checks at runtime through assertion functions and recognizing these checks at compile time. For example:
+```typescript
+function isPositive(value: number): value is Branded<number, ["positive"]> {
+    return value > 0;
+}
+
+function takesPositive(value: WithBrand<number, "positive">) {
+    // Do something with the positive value
+}
+
+const value: number = 5;
+if (isPositive(value)) {
+    // Succeeds because value has been asserted to be positive
+    takesPositive(value);
+}
+
+// Error: value may not be positive, as we cannot guarantee the assertion succeeded
+takesPositive(value);
+```
+
+### Branded<T, B extends unknown[]>
+This type returns a type that is the same as `T` except that it is branded with the type `B`.
+
+### WithBrand<T, B>
+Using the `Contains` type, this type returns `T` if it is branded with `B` and `never` otherwise.
+
+## Values
+### declare const __brand
+A unique symbol used to define type brands.
+
 ## Classes
 The following classes are available in the library:
 
@@ -97,6 +133,17 @@ This function takes a value of type `T` and a condition of type `OptionalValueCo
 #### Returns
 - `boolean` - Whether the value meets the condition.
 
+### omit<T, K extends keyof T>
+#### Description
+This function takes an object of type `T` and a list of keys `K` and returns a new object with all the keys in `K` removed.
+
+#### Parameters
+- `object` (`T`) - The object to omit keys from.
+- `keys` (`K[]`) - The keys to omit from the object.
+
+#### Returns
+- `Omit<T, K>` - The object with the keys omitted.
+
 ## Peer Dependencies
 - `is-callable^1.2.7`
 

package/dist/index.d.ts

@@ -46,3 +46,12 @@ export type Rename<T, K extends keyof T, N extends string> = Pick<T, Exclude<key
 export type ValuesIntersection<T> = ValueOf<{
     [K in keyof T]: (x: T[K]) => void;
 }> extends (x: infer I) => void ? I : never;
+export type Contains<L extends unknown[], T> = L extends [...unknown[], T] ? true : L extends [T, ...unknown[]] ? true : L extends [T] ? true : false;
+export declare const __brand: unique symbol;
+export type BrandTag<B extends unknown[]> = {
+    readonly [__brand]: B;
+};
+export type Branded<T, B extends unknown[]> = T & BrandTag<B>;
+export type WithBrand<T, B> = T extends BrandTag<unknown[]> ? (Contains<T[typeof __brand], B> extends true ? T : never) : never;
+export declare function brandValue<B extends unknown[], T>(value: T): Branded<T, B>;
+export declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;

package/dist/index.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdvancedCondition = void 0;
 exports.valueConditionMatches = valueConditionMatches;
+exports.brandValue = brandValue;
+exports.omit = omit;
 const isCallable = require("is-callable");
 class AdvancedCondition {
     constructor({ include = [], exclude = [], match = Object.is } = {}) {
@@ -40,3 +42,11 @@ function valueConditionMatches(value, condition) {
         return !excluded(value);
     return included(value) && !excluded(value);
 }
+function brandValue(value) {
+    return value;
+}
+function omit(obj, ...keys) {
+    const _ = { ...obj };
+    keys.forEach((key) => delete _[key]);
+    return _;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/ts-utils",
-    "version": "2.3.0",
+    "version": "2.5.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",