@oh-my-pi/omptype 17.2.7 → 17.2.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (35) hide show
  1. package/CHANGELOG.md +23 -0
  2. package/dist/js/compile.js +414 -219
  3. package/dist/js/errors.js +236 -41
  4. package/dist/js/from-json-schema.js +234 -0
  5. package/dist/js/index.js +1 -0
  6. package/dist/js/interp.js +514 -132
  7. package/dist/js/ir.js +972 -202
  8. package/dist/js/json-schema.js +73 -34
  9. package/dist/js/keywords.js +108 -1
  10. package/dist/js/type.js +2156 -172
  11. package/dist/js/typebox.js +41 -32
  12. package/dist/js/zod.js +2 -2
  13. package/dist/types/compile.d.ts +1 -1
  14. package/dist/types/errors.d.ts +19 -18
  15. package/dist/types/from-json-schema.d.ts +9 -0
  16. package/dist/types/index.d.ts +1 -0
  17. package/dist/types/infer.d.ts +45 -6
  18. package/dist/types/interp.d.ts +9 -2
  19. package/dist/types/ir.d.ts +57 -6
  20. package/dist/types/json-schema.d.ts +10 -1
  21. package/dist/types/type.d.ts +324 -48
  22. package/dist/types/typebox.d.ts +78 -50
  23. package/package.json +5 -1
  24. package/src/compile.ts +598 -243
  25. package/src/errors.ts +247 -49
  26. package/src/from-json-schema.ts +231 -0
  27. package/src/index.ts +1 -0
  28. package/src/infer.ts +107 -32
  29. package/src/interp.ts +457 -118
  30. package/src/ir.ts +981 -212
  31. package/src/json-schema.ts +82 -34
  32. package/src/keywords.ts +111 -1
  33. package/src/type.ts +2760 -271
  34. package/src/typebox.ts +141 -98
  35. package/src/zod.ts +1 -1
package/src/infer.ts CHANGED
@@ -13,20 +13,42 @@ type Trim<s extends string> = TrimLeft<TrimRight<s>>;
13
13
  * `never` is intentionally absent: the parser rejects it and the fallback in
14
14
  * `InferMember` treats a missing entry as "not a primitive".
15
15
  */
16
+ type ArkAny = ReturnType<typeof JSON.parse>;
17
+
16
18
  interface PrimitiveMap {
17
19
  string: string;
18
20
  "string.url": string;
19
21
  number: number;
20
22
  "number.integer": number;
23
+ "number.epoch": number;
24
+ "number.safe": number;
25
+ "number.NaN": number;
26
+ "number.Infinity": number;
27
+ "number.NegativeInfinity": number;
21
28
  boolean: boolean;
22
29
  null: null;
23
30
  undefined: undefined;
24
31
  unknown: unknown;
32
+ "unknown.any": ArkAny;
25
33
  any: unknown;
26
34
  object: object;
27
35
  bigint: bigint;
28
36
  symbol: symbol;
37
+ Key: PropertyKey;
29
38
  Date: Date;
39
+ Array: unknown[];
40
+ // biome-ignore lint/complexity/noBannedTypes: built-in Function keyword
41
+ Function: Function;
42
+ RegExp: RegExp;
43
+ File: File;
44
+ Error: Error;
45
+ Set: Set<unknown>;
46
+ Map: Map<unknown, unknown>;
47
+ WeakSet: WeakSet<WeakKey>;
48
+ WeakMap: WeakMap<WeakKey, unknown>;
49
+ Promise: Promise<unknown>;
50
+ FormData: FormData;
51
+ "object.json": unknown;
30
52
  true: true;
31
53
  false: false;
32
54
  }
@@ -39,7 +61,7 @@ type Merge<left, right> = left extends object
39
61
 
40
62
  type InferUtility<s extends string> = s extends `Record<${string},${infer value}>`
41
63
  ? Record<string, InferString<value>>
42
- : s extends `Array<${infer element}>`
64
+ : s extends `Array<${infer element}>` | `Array.liftFrom<${infer element}>`
43
65
  ? InferString<element>[]
44
66
  : s extends `Partial<${infer value}>`
45
67
  ? Partial<InferString<value>>
@@ -53,6 +75,29 @@ type InferUtility<s extends string> = s extends `Record<${string},${infer value}
53
75
  ? Merge<InferString<left>, InferString<right>>
54
76
  : never;
55
77
 
78
+ /** Output types of morph (`.parse`) keywords; `never` when `s` is not one. */
79
+ type InferParse<s extends string> = s extends
80
+ | "string.numeric.parse"
81
+ | "string.integer.parse"
82
+ | "parse.number"
83
+ | "parse.integer"
84
+ ? number
85
+ : s extends "string.date.parse" | "string.date.iso.parse" | "string.date.epoch.parse" | "parse.date"
86
+ ? Date
87
+ : s extends "string.url.parse" | "parse.url"
88
+ ? URL
89
+ : s extends "string.json.parse" | "parse.json"
90
+ ? unknown
91
+ : s extends "object.json.stringify"
92
+ ? string
93
+ : s extends "FormData.parse"
94
+ ? Record<string, Bun.FormDataEntryValue | Bun.FormDataEntryValue[]>
95
+ : s extends "parse.boolean"
96
+ ? boolean
97
+ : s extends "parse.bigint"
98
+ ? bigint
99
+ : never;
100
+
56
101
  /**
57
102
  * Member inference as a flat false-branch chain: TypeScript tail-evaluates
58
103
  * chained conditionals in the false position, so this stays at constant
@@ -77,11 +122,13 @@ type InferMemberTrimmed<s extends string> = s extends `(${infer inner})`
77
122
  ? literal
78
123
  : s extends keyof PrimitiveMap
79
124
  ? PrimitiveMap[s]
80
- : InferUtility<s> extends infer utility
81
- ? [utility] extends [never]
82
- ? InferMemberFallback<s>
83
- : utility
84
- : unknown;
125
+ : [InferParse<s>] extends [never]
126
+ ? InferUtility<s> extends infer utility
127
+ ? [utility] extends [never]
128
+ ? InferMemberFallback<s>
129
+ : utility
130
+ : unknown
131
+ : InferParse<s>;
85
132
 
86
133
  type InferMemberFallback<s extends string> = s extends `string.${string}`
87
134
  ? string
@@ -98,6 +145,19 @@ type InferUnion<s extends string, result = never> = s extends `${infer head}|${i
98
145
  ? InferUnion<tail, result | InferMember<head>>
99
146
  : result | InferMember<s>;
100
147
 
148
+ /** Input side of one union member: morph keywords accept their source type. */
149
+ type InferMemberIn<member extends string> =
150
+ Trim<member> extends infer s extends string
151
+ ? s extends `${string}.parse` | `parse.${string}`
152
+ ? string
153
+ : InferMemberTrimmed<s>
154
+ : unknown;
155
+
156
+ /** Split unions on the input side without distributing over accumulated members. */
157
+ type InferUnionIn<s extends string, result = never> = s extends `${infer head}|${infer tail}`
158
+ ? InferUnionIn<tail, result | InferMemberIn<head>>
159
+ : result | InferMemberIn<s>;
160
+
101
161
  type HasInlineDefault<s extends string> = s extends `${string}=${string}`
102
162
  ? s extends `${string}<${string}` | `${string}>${string}`
103
163
  ? false
@@ -107,23 +167,7 @@ type HasInlineDefault<s extends string> = s extends `${string}=${string}`
107
167
  type WithoutInlineDefault<s extends string> =
108
168
  HasInlineDefault<s> extends true ? (s extends `${infer base}=${string}` ? Trim<base> : s) : s;
109
169
 
110
- type InferStringOutput<s extends string> = s extends
111
- | "string.numeric.parse"
112
- | "string.integer.parse"
113
- | "parse.number"
114
- | "parse.integer"
115
- ? number
116
- : s extends "string.date.parse" | "string.date.iso.parse" | "string.date.epoch.parse" | "parse.date"
117
- ? Date
118
- : s extends "string.url.parse" | "parse.url"
119
- ? URL
120
- : s extends "string.json.parse" | "parse.json"
121
- ? unknown
122
- : s extends "parse.boolean"
123
- ? boolean
124
- : s extends "parse.bigint"
125
- ? bigint
126
- : InferUnion<s>;
170
+ type InferStringOutput<s extends string> = InferUnion<s>;
127
171
 
128
172
  /** String-DSL output inference. */
129
173
  export type InferString<s extends string> =
@@ -138,9 +182,11 @@ export type InferString<s extends string> =
138
182
  /** String-DSL input inference, preserving the source side of morph keywords. */
139
183
  export type InferStringIn<s extends string> =
140
184
  WithoutInlineDefault<Trim<s>> extends infer trimmed extends string
141
- ? trimmed extends `${string}.parse` | `parse.${string}`
142
- ? string
143
- : InferString<trimmed>
185
+ ? trimmed extends `${infer base}?`
186
+ ? InferStringIn<base>
187
+ : trimmed extends `(${infer inner})[]`
188
+ ? InferUnionIn<inner>[]
189
+ : InferUnionIn<trimmed>
144
190
  : unknown;
145
191
 
146
192
  type HasDefault<def> = def extends string
@@ -239,11 +285,21 @@ type InferObjectIn<def extends object> = "[string]" extends keyof def
239
285
  /** Object-literal inference used by fluent composition overloads. */
240
286
  export type InferObjectDef<def extends object> = InferObject<def>;
241
287
 
242
- type InferLiteralDef<def> = def extends string
243
- ? InferString<def>
244
- : def extends object
245
- ? InferObjectLiteral<def>
246
- : unknown;
288
+ type InferLiteralDef<def> = def extends { readonly infer: infer output }
289
+ ? output
290
+ : def extends string
291
+ ? InferString<def>
292
+ : def extends object
293
+ ? InferObjectLiteral<def>
294
+ : unknown;
295
+
296
+ type InferLiteralDefIn<def> = def extends { readonly inferIn: infer input }
297
+ ? input
298
+ : def extends string
299
+ ? InferStringIn<def>
300
+ : def extends object
301
+ ? InferObjectLiteralIn<def>
302
+ : unknown;
247
303
 
248
304
  type LiteralRequired<def extends object> = {
249
305
  -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
@@ -261,9 +317,28 @@ type LiteralOptional<def extends object> = {
261
317
  : never]?: InferLiteralDef<UnwrapProperty<def[key]>>;
262
318
  };
263
319
 
264
- /** Object-literal-only inference that does not inspect embedded schema internals. */
320
+ type LiteralRequiredIn<def extends object> = {
321
+ -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
322
+ ? never
323
+ : HasDefault<def[key]> extends true
324
+ ? never
325
+ : PropName<key>]-?: InferLiteralDefIn<UnwrapProperty<def[key]>>;
326
+ };
327
+
328
+ type LiteralOptionalIn<def extends object> = {
329
+ -readonly [key in DefinitionKeys<def> as IsOptionalProp<key, def[key]> extends true
330
+ ? PropName<key>
331
+ : HasDefault<def[key]> extends true
332
+ ? PropName<key>
333
+ : never]?: InferLiteralDefIn<UnwrapProperty<def[key]>>;
334
+ };
335
+
336
+ /** Object-literal inference that unwraps embedded schema values one level deep. */
265
337
  export type InferObjectLiteral<def extends object> = Simplify<LiteralRequired<def> & LiteralOptional<def>>;
266
338
 
339
+ /** Input-side object-literal inference (embedded schemas contribute `inferIn`). */
340
+ export type InferObjectLiteralIn<def extends object> = Simplify<LiteralRequiredIn<def> & LiteralOptionalIn<def>>;
341
+
267
342
  type InstanceOf<ctor> = ctor extends abstract new (...args: never[]) => infer instance ? instance : never;
268
343
  type SpreadOutput<def> = InferDef<def> extends readonly (infer element)[] ? element[] : never[];
269
344
  type SpreadInput<def> = InferDefIn<def> extends readonly (infer element)[] ? element[] : never[];