typetify 0.1.1

package/dist/typed/index.js

@@ -0,0 +1,193 @@
+'use strict';
+
+var chunkSIA5BSVY_js = require('../chunk-SIA5BSVY.js');
+require('../chunk-PZ5AY32C.js');
+
+
+
+Object.defineProperty(exports, "assertTypeDebug", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.assertType; }
+});
+Object.defineProperty(exports, "asyncData", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.asyncData; }
+});
+Object.defineProperty(exports, "brand", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.brand; }
+});
+Object.defineProperty(exports, "collection", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.collection; }
+});
+Object.defineProperty(exports, "collectionWithId", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.collectionWithId; }
+});
+Object.defineProperty(exports, "createActions", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.createActions; }
+});
+Object.defineProperty(exports, "createBuilder", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.createBuilder; }
+});
+Object.defineProperty(exports, "createCollection", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.createCollection; }
+});
+Object.defineProperty(exports, "createMap", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.createMap; }
+});
+Object.defineProperty(exports, "createMatcher", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.createMatcher; }
+});
+Object.defineProperty(exports, "createReducer", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.createReducer; }
+});
+Object.defineProperty(exports, "createSet", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.createSet; }
+});
+Object.defineProperty(exports, "createTypedEmitter", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.createTypedEmitter; }
+});
+Object.defineProperty(exports, "deepMergeFn", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.deepMerge; }
+});
+Object.defineProperty(exports, "defineConst", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.defineConst; }
+});
+Object.defineProperty(exports, "defineEnum", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.defineEnum; }
+});
+Object.defineProperty(exports, "defineModel", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.defineModel; }
+});
+Object.defineProperty(exports, "defineStateMachine", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.defineStateMachine; }
+});
+Object.defineProperty(exports, "defineTuple", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.defineTuple; }
+});
+Object.defineProperty(exports, "formState", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.formState; }
+});
+Object.defineProperty(exports, "fromEntries", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.fromEntries; }
+});
+Object.defineProperty(exports, "identityTyped", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.identity; }
+});
+Object.defineProperty(exports, "impossible", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.impossible; }
+});
+Object.defineProperty(exports, "mapKeys", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.mapKeys; }
+});
+Object.defineProperty(exports, "mapValues", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.mapValues; }
+});
+Object.defineProperty(exports, "match", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.match; }
+});
+Object.defineProperty(exports, "matchUnion", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.matchUnion; }
+});
+Object.defineProperty(exports, "matchValue", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.matchValue; }
+});
+Object.defineProperty(exports, "merge", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.merge; }
+});
+Object.defineProperty(exports, "mergeAllFn", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.mergeAll; }
+});
+Object.defineProperty(exports, "mergeModels", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.mergeModels; }
+});
+Object.defineProperty(exports, "mergeWith", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.mergeWith; }
+});
+Object.defineProperty(exports, "modalState", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.modalState; }
+});
+Object.defineProperty(exports, "model", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.model; }
+});
+Object.defineProperty(exports, "narrow", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.narrow; }
+});
+Object.defineProperty(exports, "narrowTyped", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.narrow2; }
+});
+Object.defineProperty(exports, "omitModel", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.omitModel; }
+});
+Object.defineProperty(exports, "omitTyped", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.omit; }
+});
+Object.defineProperty(exports, "persistentCollection", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.persistentCollection; }
+});
+Object.defineProperty(exports, "pickModel", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.pickModel; }
+});
+Object.defineProperty(exports, "pickTyped", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.pick; }
+});
+Object.defineProperty(exports, "renameKeys", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.renameKeys; }
+});
+Object.defineProperty(exports, "showType", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.showType; }
+});
+Object.defineProperty(exports, "t", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.t; }
+});
+Object.defineProperty(exports, "undoable", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.undoable; }
+});
+Object.defineProperty(exports, "v", {
+  enumerable: true,
+  get: function () { return chunkSIA5BSVY_js.v; }
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/typed/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/typed/index.mjs

@@ -0,0 +1,4 @@
+export { assertType as assertTypeDebug, asyncData, brand, collection, collectionWithId, createActions, createBuilder, createCollection, createMap, createMatcher, createReducer, createSet, createTypedEmitter, deepMerge as deepMergeFn, defineConst, defineEnum, defineModel, defineStateMachine, defineTuple, formState, fromEntries, identity as identityTyped, impossible, mapKeys, mapValues, match, matchUnion, matchValue, merge, mergeAll as mergeAllFn, mergeModels, mergeWith, modalState, model, narrow, narrow2 as narrowTyped, omitModel, omit as omitTyped, persistentCollection, pickModel, pick as pickTyped, renameKeys, showType, t, undoable, v } from '../chunk-JAOGY4JO.mjs';
+import '../chunk-J5LGTIGS.mjs';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/typed/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/types-Db0vauC3.d.mts

@@ -0,0 +1,258 @@
+/**
+ * Creates a readonly constant with inferred literal type.
+ * Useful for defining constants that TypeScript will narrow.
+ *
+ * @example
+ * const STATUS = defineConst({
+ *   PENDING: 'pending',
+ *   ACTIVE: 'active',
+ *   DONE: 'done',
+ * })
+ * // typeof STATUS.PENDING = 'pending' (not string)
+ */
+declare function defineConst<T extends Record<string, unknown>>(obj: T): Readonly<T>;
+
+/**
+ * Creates an enum-like object with proper typing.
+ * Values are the same as keys.
+ *
+ * @example
+ * const Status = defineEnum(['pending', 'active', 'done'] as const)
+ * // Status.pending = 'pending'
+ * // type StatusValue = 'pending' | 'active' | 'done'
+ */
+declare function defineEnum<T extends readonly string[]>(values: T): {
+    readonly [K in T[number]]: K;
+};
+/**
+ * Extracts the value type from a defineEnum result.
+ *
+ * @example
+ * const Status = defineEnum(['pending', 'active', 'done'] as const)
+ * type StatusValue = EnumValue<typeof Status> // 'pending' | 'active' | 'done'
+ */
+type EnumValue<T extends Record<string, string>> = T[keyof T];
+
+/**
+ * Creates a tuple with inferred literal types.
+ * Useful when you need a tuple type without using 'as const'.
+ *
+ * @example
+ * const coords = defineTuple(10, 20, 30)
+ * // type: [number, number, number]
+ *
+ * const status = defineTuple('pending', 'active', 'done')
+ * // type: ['pending', 'active', 'done']
+ */
+declare function defineTuple<T extends readonly unknown[]>(...args: T): T;
+
+/**
+ * Creates a type-safe Map with inferred key and value types.
+ *
+ * @example
+ * const userMap = createMap<number, { name: string }>()
+ * userMap.set(1, { name: 'John' })
+ * const user = userMap.get(1) // { name: string } | undefined
+ */
+declare function createMap<K, V>(entries?: readonly (readonly [K, V])[]): Map<K, V>;
+
+/**
+ * Creates a type-safe Set with inferred value type.
+ *
+ * @example
+ * const ids = createSet<number>()
+ * ids.add(1)
+ * ids.has(1) // true
+ */
+declare function createSet<T>(values?: readonly T[]): Set<T>;
+
+declare const __brand: unique symbol;
+/**
+ * Creates a branded type. Branded types are structurally identical
+ * but nominally different, preventing accidental mixing.
+ *
+ * @example
+ * type UserId = Brand<number, 'UserId'>
+ * type PostId = Brand<number, 'PostId'>
+ *
+ * const userId = 1 as UserId
+ * const postId = 2 as PostId
+ *
+ * function getUser(id: UserId) { ... }
+ * getUser(userId) // OK
+ * getUser(postId) // Error!
+ */
+type Brand<T, B extends string> = T & {
+    readonly [__brand]: B;
+};
+/**
+ * Creates a branded value.
+ *
+ * @example
+ * type UserId = Brand<number, 'UserId'>
+ * const userId = brand<UserId>(1)
+ */
+declare function brand<T extends Brand<unknown, string>>(value: T extends Brand<infer U, string> ? U : never): T;
+
+/**
+ * Narrows a value to a specific type using a type guard.
+ * Returns the value if it passes the guard, undefined otherwise.
+ *
+ * @example
+ * const value: unknown = 'hello'
+ * const str = narrow(value, isString)
+ * // str is string | undefined
+ */
+declare function narrow<T, U extends T>(value: T, guard: (value: T) => value is U): U | undefined;
+
+/**
+ * Makes all properties of T optional recursively.
+ */
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+/**
+ * Makes all properties of T readonly recursively.
+ */
+type DeepReadonly<T> = T extends object ? {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+} : T;
+/**
+ * Makes all properties of T required recursively.
+ */
+type DeepRequired<T> = T extends object ? {
+    [P in keyof T]-?: DeepRequired<T[P]>;
+} : T;
+/**
+ * Extracts the element type from an array.
+ */
+type ElementOf<T> = T extends readonly (infer E)[] ? E : never;
+/**
+ * Makes specified keys required.
+ */
+type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
+/**
+ * Makes specified keys optional.
+ */
+type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Extracts keys of T that have values of type V.
+ */
+type KeysOfType<T, V> = {
+    [K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
+/**
+ * Makes a type mutable (removes readonly).
+ */
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/**
+ * Extracts the resolved type of a Promise.
+ */
+type Awaited<T> = T extends Promise<infer U> ? U : T;
+/**
+ * Creates a union of all values in an object.
+ */
+type ValueOf<T> = T[keyof T];
+/**
+ * Excludes null and undefined from T.
+ */
+type NonNullableDeep<T> = T extends object ? {
+    [P in keyof T]: NonNullableDeep<NonNullable<T[P]>>;
+} : NonNullable<T>;
+/**
+ * Makes the type nullable.
+ */
+type Nullable<T> = T | null;
+/**
+ * Makes the type optional (can be undefined).
+ */
+type Optional<T> = T | undefined;
+/**
+ * Merge two types, with the second type overriding the first.
+ */
+type Merge<T, U> = Omit<T, keyof U> & U;
+/**
+ * Require at least one of the specified keys.
+ */
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+/**
+ * Require exactly one of the specified keys.
+ */
+type RequireExactlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, never>>;
+}[Keys];
+/**
+ * Prettify a type for better IntelliSense display.
+ * Flattens intersections into a single object type.
+ */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Makes specified keys partial while keeping others required.
+ */
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Makes specified keys required while keeping others as-is.
+ */
+type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/**
+ * Converts a union type to an intersection type.
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Extracts the resolved value type from a Promise.
+ */
+type PromiseValue<T> = T extends Promise<infer U> ? U : T;
+/**
+ * Extracts the element type from an array type.
+ */
+type ArrayElement<T> = T extends readonly (infer U)[] ? U : never;
+/**
+ * Creates a type that requires all properties to match exactly.
+ */
+type Exact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? T : never : never;
+/**
+ * Creates a type with all properties set to never.
+ */
+type Never<T> = {
+    [K in keyof T]?: never;
+};
+/**
+ * Makes all properties writable (removes readonly) recursively.
+ */
+type DeepMutable<T> = T extends object ? {
+    -readonly [P in keyof T]: DeepMutable<T[P]>;
+} : T;
+/**
+ * Extracts keys that are required in T.
+ */
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+/**
+ * Extracts keys that are optional in T.
+ */
+type OptionalKeysOf<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
+/**
+ * Creates a type where at least one property must be defined.
+ */
+type AtLeastOne<T> = {
+    [K in keyof T]: Pick<T, K> & Partial<Omit<T, K>>;
+}[keyof T];
+/**
+ * Creates a record type with string keys and values of type T.
+ */
+type Dictionary<T> = Record<string, T>;
+/**
+ * Creates a readonly record type.
+ */
+type ReadonlyDictionary<T> = Readonly<Record<string, T>>;
+
+export { type ArrayElement as A, type Brand as B, type RequiredKeys as C, type DeepPartial as D, type ElementOf as E, type KeysOfType as K, type Merge as M, type NonNullableDeep as N, type Optional as O, type PartialBy as P, type ReadonlyDictionary as R, type UnionToIntersection as U, type ValueOf as V, type Awaited as a, type DeepReadonly as b, type DeepRequired as c, type Dictionary as d, type EnumValue as e, type Mutable as f, type Nullable as g, type OptionalKeys as h, type Prettify as i, type PromiseValue as j, type RequireAtLeastOne as k, type RequireExactlyOne as l, type RequireKeys as m, type RequiredBy as n, brand as o, createMap as p, createSet as q, defineConst as r, defineEnum as s, defineTuple as t, narrow as u, type AtLeastOne as v, type DeepMutable as w, type Exact as x, type Never as y, type OptionalKeysOf as z };