@stryke/types 0.0.1

package/dist/type-checks/is-undefined.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isUndefined = void 0;
+const isUndefined = n => n === void 0;
+exports.isUndefined = isUndefined;

package/dist/type-checks/is-undefined.d.ts

@@ -0,0 +1 @@
+export declare const isUndefined: (value: unknown) => value is undefined;

package/dist/type-checks/is-undefined.mjs

@@ -0,0 +1 @@
+export const isUndefined=n=>n===void 0;

package/dist/type-checks/property-exists.cjs

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.propertyUnsafe = exports.propertyExists = void 0;
+var _isObject = require("./is-object.cjs");
+const propertyExists = (r, t) => {
+    try {
+      return (0, _isObject.isObject)(r) && t in r;
+    } catch {
+      return !1;
+    }
+  },
+  propertyUnsafe = (r, t) => propertyExists(r, t) && !(Object.hasOwnProperty.call(r, t) && Object.propertyIsEnumerable.call(r, t));
+exports.propertyUnsafe = propertyUnsafe;
+exports.propertyExists = propertyExists;

package/dist/type-checks/property-exists.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Check if the provided object has the provided property
+ *
+ * @param object - The object to check
+ * @param propertyKey - The property to check
+ * @returns An indicator specifying if the object has the provided property
+ */
+export declare const propertyExists: (object: any, propertyKey: PropertyKey) => boolean;
+/**
+ * Check if the provided object has the provided property and if it's safe to merge
+ *
+ * @param object - The object to check
+ * @param propertyKey - The property to check
+ * @returns An indicator specifying if the object has the provided property and if it's safe to merge
+ */
+export declare const propertyUnsafe: (object: any, propertyKey: PropertyKey) => boolean;

package/dist/type-checks/property-exists.mjs

@@ -0,0 +1 @@
+import{isObject as e}from"./is-object";export const propertyExists=(r,t)=>{try{return e(r)&&t in r}catch{return!1}},propertyUnsafe=(r,t)=>propertyExists(r,t)&&!(Object.hasOwnProperty.call(r,t)&&Object.propertyIsEnumerable.call(r,t));

package/dist/type-checks/type-detect.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeDetect = typeDetect;
+var _isBuffer = require("./is-buffer.cjs");
+const a = (t => (typeof globalThis == "object" || Object.defineProperty(t, "typeDetectGlobalObject", {
+  get() {
+    return this;
+  },
+  configurable: !0
+}), globalThis))(Object.prototype);
+function typeDetect(t) {
+  if ((0, _isBuffer.isBuffer)(t)) return "Buffer";
+  const r = typeof t;
+  if (r !== "object") return r;
+  if (t === null) return "null";
+  if (t === a) return "global";
+  if (Array.isArray(t) && (Symbol.toStringTag === void 0 || !(Symbol.toStringTag in t))) return "Array";
+  if (typeof globalThis == "object" && globalThis !== null) {
+    if (typeof globalThis.location == "object" && t === globalThis.location) return "Location";
+    if (typeof globalThis.document == "object" && t === globalThis.document) return "Document";
+    if (typeof globalThis.navigator == "object") {
+      if (typeof globalThis.navigator.mimeTypes == "object" && t === globalThis.navigator.mimeTypes) return "MimeTypeArray";
+      if (typeof globalThis.navigator.plugins == "object" && t === globalThis.navigator.plugins) return "PluginArray";
+    }
+    if ((typeof globalThis.HTMLElement == "function" || typeof globalThis.HTMLElement == "object") && t instanceof globalThis.HTMLElement) {
+      if (t.tagName === "BLOCKQUOTE") return "HTMLQuoteElement";
+      if (t.tagName === "TD") return "HTMLTableDataCellElement";
+      if (t.tagName === "TH") return "HTMLTableHeaderCellElement";
+    }
+  }
+  const o = Symbol.toStringTag !== void 0 && t[Symbol.toStringTag];
+  if (typeof o == "string") return o;
+  const e = Object.getPrototypeOf(t);
+  return e === RegExp.prototype ? "RegExp" : e === Date.prototype ? "Date" : typeof Promise < "u" && e === Promise.prototype ? "Promise" : typeof Set < "u" && e === Set.prototype ? "Set" : typeof Map < "u" && e === Map.prototype ? "Map" : typeof WeakSet < "u" && e === WeakSet.prototype ? "WeakSet" : typeof WeakMap < "u" && e === WeakMap.prototype ? "WeakMap" : typeof DataView < "u" && e === DataView.prototype ? "DataView" : typeof Map < "u" && e === Object.getPrototypeOf(new Map().entries()) ? "Map Iterator" : typeof Set < "u" && e === Object.getPrototypeOf(new Set().entries()) ? "Set Iterator" : typeof Array.prototype[Symbol.iterator] == "function" && e === Object.getPrototypeOf([][Symbol.iterator]()) ? "Array Iterator" : Symbol.iterator !== void 0 && typeof String.prototype[Symbol.iterator] == "function" && Object.getPrototypeOf(""[Symbol.iterator]()) && e === Object.getPrototypeOf(""[Symbol.iterator]()) ? "String Iterator" : e === null ? "Object" : Object.prototype.toString.call(t).slice(8, -1);
+}

package/dist/type-checks/type-detect.d.ts

@@ -0,0 +1 @@
+export declare function typeDetect(obj: unknown): string;

package/dist/type-checks/type-detect.mjs

@@ -0,0 +1 @@
+import{isBuffer as n}from"./is-buffer";const a=(t=>(typeof globalThis=="object"||Object.defineProperty(t,"typeDetectGlobalObject",{get(){return this},configurable:!0}),globalThis))(Object.prototype);export function typeDetect(t){if(n(t))return"Buffer";const r=typeof t;if(r!=="object")return r;if(t===null)return"null";if(t===a)return"global";if(Array.isArray(t)&&(Symbol.toStringTag===void 0||!(Symbol.toStringTag in t)))return"Array";if(typeof globalThis=="object"&&globalThis!==null){if(typeof globalThis.location=="object"&&t===globalThis.location)return"Location";if(typeof globalThis.document=="object"&&t===globalThis.document)return"Document";if(typeof globalThis.navigator=="object"){if(typeof globalThis.navigator.mimeTypes=="object"&&t===globalThis.navigator.mimeTypes)return"MimeTypeArray";if(typeof globalThis.navigator.plugins=="object"&&t===globalThis.navigator.plugins)return"PluginArray"}if((typeof globalThis.HTMLElement=="function"||typeof globalThis.HTMLElement=="object")&&t instanceof globalThis.HTMLElement){if(t.tagName==="BLOCKQUOTE")return"HTMLQuoteElement";if(t.tagName==="TD")return"HTMLTableDataCellElement";if(t.tagName==="TH")return"HTMLTableHeaderCellElement"}}const o=Symbol.toStringTag!==void 0&&t[Symbol.toStringTag];if(typeof o=="string")return o;const e=Object.getPrototypeOf(t);return e===RegExp.prototype?"RegExp":e===Date.prototype?"Date":typeof Promise<"u"&&e===Promise.prototype?"Promise":typeof Set<"u"&&e===Set.prototype?"Set":typeof Map<"u"&&e===Map.prototype?"Map":typeof WeakSet<"u"&&e===WeakSet.prototype?"WeakSet":typeof WeakMap<"u"&&e===WeakMap.prototype?"WeakMap":typeof DataView<"u"&&e===DataView.prototype?"DataView":typeof Map<"u"&&e===Object.getPrototypeOf(new Map().entries())?"Map Iterator":typeof Set<"u"&&e===Object.getPrototypeOf(new Set().entries())?"Set Iterator":typeof Array.prototype[Symbol.iterator]=="function"&&e===Object.getPrototypeOf([][Symbol.iterator]())?"Array Iterator":Symbol.iterator!==void 0&&typeof String.prototype[Symbol.iterator]=="function"&&Object.getPrototypeOf(""[Symbol.iterator]())&&e===Object.getPrototypeOf(""[Symbol.iterator]())?"String Iterator":e===null?"Object":Object.prototype.toString.call(t).slice(8,-1)}

package/dist/utility-types/array.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterEmpty = void 0;
+var _typeChecks = require("../type-checks/index.cjs");
+const filterEmpty = (e = []) => e.filter(n => !(0, _typeChecks.isEmpty)(n));
+exports.filterEmpty = filterEmpty;

package/dist/utility-types/array.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Matches any array or array-like object.
+ *
+ * @category Array
+ */
+export type Arrayable<T> = T | T[];
+export type UnknownArray = readonly unknown[];
+/**
+ * Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+ *
+ * @category Array
+ */
+export type TypedArray = BigInt64Array | BigUint64Array | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+/**
+ * Infer the length of the given array `<T>`.
+ *
+ * Check out {@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f | this article} for more information.
+ */
+export type ArrayLength<T extends readonly unknown[]> = T extends {
+    readonly length: infer L;
+} ? L : never;
+/**
+ * Extract the element of an array that also works for array union.
+ *
+ * Returns `never` if T is not an array.
+ *
+ * It creates a type-safe way to access the element type of `unknown` type.
+ */
+export type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+/**
+ * Provides all values for a constant array or tuple.
+ *
+ * Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
+ *
+ * @example
+ * ```
+ * import type {ArrayValues, ArrayIndices} from 'type-fest';
+ *
+ * const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+ *
+ * type WeekdayName = ArrayValues<typeof weekdays>;
+ * type Weekday = ArrayIndices<typeof weekdays>;
+ *
+ * const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+ * ```
+ *
+ * @see {@link ArrayIndices}
+ *
+ * @category Array
+ */
+export type ArrayValues<T extends readonly unknown[]> = T[number];
+/**
+ * Provides valid indices for a constant array or tuple.
+ *
+ * Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety for accessing elements by their indices.
+ *
+ * @example
+ * ```
+ * import type {ArrayIndices, ArrayValues} from 'type-fest';
+ *
+ * const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+ *
+ * type Weekday = ArrayIndices<typeof weekdays>;
+ * type WeekdayName = ArrayValues<typeof weekdays>;
+ *
+ * const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+ * ```
+ *
+ * @see {@link ArrayValues}
+ *
+ * @category Array
+ */
+export type ArrayIndices<Element extends readonly unknown[]> = Exclude<Partial<Element>["length"], Element["length"]>;
+/**
+ * Matches any unknown array or tuple.
+ */
+export type UnknownArrayOrTuple = readonly [...unknown[]];
+/**
+ * Extracts the type of the first element of an array or tuple.
+ */
+export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]] ? THead : never;
+/**
+ * Extracts the type of the last element of an array.
+ *
+ * Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
+ *
+ * @example
+ * ```
+ * import type {LastArrayElement} from 'type-fest';
+ *
+ * declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
+ *
+ * const array = ['foo', 2];
+ *
+ * typeof lastOf(array);
+ * //=> number
+ *
+ * const array = ['foo', 2] as const;
+ *
+ * typeof lastOf(array);
+ * //=> 2
+ * ```
+ *
+ * @category Array
+ * @category Template literal
+ */
+export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> = Elements extends readonly [] ? ElementBeforeTailingSpreadElement : Elements extends readonly [...infer _U, infer V] ? V : Elements extends readonly [infer U, ...infer V] ? LastArrayElement<V, U> : Elements extends readonly (infer U)[] ? ElementBeforeTailingSpreadElement | U : never;
+/**
+ * Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+ *
+ * @example
+ * ```
+ * type A = [string, number, boolean, ...string[]];
+ * type B = StaticPartOfArray<A>;
+ * //=> [string, number, boolean]
+ * ```
+ */
+export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> = T extends unknown ? number extends T["length"] ? T extends readonly [infer U, ...infer V] ? StaticPartOfArray<V, [...Result, U]> : Result : T : never;
+/**
+ * Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
+ *
+ * @example
+ * ```
+ * type A = [string, number, boolean, ...string[]];
+ * type B = VariablePartOfArray<A>;
+ * //=> string[]
+ * ```
+ */
+export type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [...StaticPartOfArray<T>, ...infer U] ? U : [] : never;
+export declare const filterEmpty: <T>(values?: (T | null | undefined)[]) => T[];

package/dist/utility-types/array.mjs

@@ -0,0 +1 @@
+import{isEmpty as r}from"../type-checks";export const filterEmpty=(e=[])=>e.filter(n=>!r(n));

package/dist/utility-types/async.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/utility-types/async.d.ts

@@ -0,0 +1,103 @@
+import type { FunctionLike, IsUnknown } from "./base";
+/**
+ * Get the type of the value that a promise resolves to.
+ *
+ * @example
+ * ```
+ * import type {Awaited} from 'type-fest';
+ *
+ * const value: Awaited<Promise<string>> = 'foo';
+ * ```
+ *
+ * @category Async
+ */
+export type Awaitable<T> = T | PromiseLike<T>;
+/**
+ * Create a function type with a return type of your choice and the same parameters as the given function type.
+ *
+ * Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
+ *
+ * @example
+ * ```
+ * import type {SetReturnType} from 'type-fest';
+ *
+ * type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
+ *
+ * type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
+ * //=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
+ * ```
+ *
+ * @category Function
+ */
+export type SetReturnType<Function_ extends (...arguments_: any[]) => any, TypeToReturn> = Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => any ? IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn : (...arguments_: Parameters<Function_>) => TypeToReturn;
+export type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
+/**
+ * Unwrap the return type of a function that returns a `Promise`.
+ *
+ * There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
+ *
+ * @example
+ * ```ts
+ * import type {AsyncReturnType} from 'type-fest';
+ * import {asyncFunction} from 'api';
+ *
+ * // This type resolves to the unwrapped return type of `asyncFunction`.
+ * type Value = AsyncReturnType<typeof asyncFunction>;
+ *
+ * async function doSomething(value: Value) {}
+ *
+ * asyncFunction().then(value => doSomething(value));
+ * ```
+ *
+ * @category Async
+ */
+export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;
+/**
+ * Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
+ *
+ * Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
+ *
+ * @example
+ * ```
+ * import type {Asyncify} from 'type-fest';
+ *
+ * // Synchronous function.
+ * function getFooSync(someArg: SomeType): Foo {
+ *   // …
+ * }
+ *
+ * type AsyncifiedFooGetter = Asyncify<typeof getFooSync>;
+ * //=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise<Foo>;
+ *
+ * // Same as `getFooSync` but asynchronous.
+ * const getFooAsync: AsyncifiedFooGetter = (someArg) => {
+ *   // TypeScript now knows that `someArg` is `SomeType` automatically.
+ *   // It also knows that this function must return `Promise<Foo>`.
+ *   // If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.".
+ *
+ *   // …
+ * }
+ * ```
+ *
+ * @category Async
+ */
+export type Asyncify<Function_ extends FunctionLike> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;
+/**
+ * Get the result type of a `Promise`
+ *
+ * @example
+ * ```ts
+ * import { Await } from '@stryke/types'
+ *
+ * const promise = new Promise<string>((res, rej) => res('x'))
+ *
+ * type test0 = C.Await<typeof promise>  // string
+ * type test1 = C.Await<Promise<number>> // number
+ * ```
+ *
+ * @param P - A promise
+ * @returns [[Any]]
+ *
+ * @category Async
+ */
+export type Await<P extends any> = P extends Promise<infer A> ? A : P;

package/dist/utility-types/base.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TYPE_SET = exports.TYPE_OBJECT = exports.TYPE_MAP = exports.TYPE_ARRAY = exports.TYPE_ARGUMENTS = exports.NEWLINE_STRING = exports.EMPTY_STRING = exports.EMPTY_OBJECT = exports.$NestedValue = void 0;
+const EMPTY_STRING = exports.EMPTY_STRING = "",
+  NEWLINE_STRING = exports.NEWLINE_STRING = `\r
+`,
+  EMPTY_OBJECT = exports.EMPTY_OBJECT = {},
+  TYPE_ARGUMENTS = exports.TYPE_ARGUMENTS = "Arguments",
+  TYPE_ARRAY = exports.TYPE_ARRAY = "Array",
+  TYPE_OBJECT = exports.TYPE_OBJECT = "Object",
+  TYPE_MAP = exports.TYPE_MAP = "Map",
+  TYPE_SET = exports.TYPE_SET = "Set",
+  $NestedValue = exports.$NestedValue = Symbol("NestedValue");