Version 1.0.76 (#1509)

* KeyOf Record with TemplateLiteral

* Tests

* Coverage

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.76](https://github.com/sinclairzx81/typebox/pull/1509)
+  - Derive KeyOf from Record types with TemplateLiteral Keys
 - [Revision 1.0.75](https://github.com/sinclairzx81/typebox/pull/1507)
   - Fix Embedded Union Intersect Distribution Rule
 - [Revision 1.0.74](https://github.com/sinclairzx81/typebox/pull/1505)

src/type/engine/evaluate/distribute.ts

@@ -54,22 +54,13 @@ function IsObjectLike<Type extends TSchema>(type: Type) {
 type TIsUnionOperand<Left extends TSchema, Right extends TSchema,
   IsUnionLeft extends boolean = Left extends TUnion ? true : false,
   IsUnionRight extends boolean = Right extends TUnion ? true : false,
-  Result extends boolean = (
-    [IsUnionLeft, IsUnionRight] extends [true, true] ? true :
-    [IsUnionLeft, IsUnionRight] extends [false, true] ? true :
-    [IsUnionLeft, IsUnionRight] extends [true, false] ? true :
-    false
-  )
+  Result extends boolean = IsUnionLeft extends true ? true : IsUnionRight extends true ? true : false
 > = Result
 function IsUnionOperand<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TIsUnionOperand<Left, Right> {
   const isUnionLeft = IsUnion(left)
   const isUnionRight = IsUnion(right)
-  return (
-    isUnionLeft && isUnionRight ? true :
-    !isUnionLeft && isUnionRight ? true :
-    isUnionLeft && !isUnionRight ? true :
-    false
-  ) as never
+  const result = isUnionLeft || isUnionRight
+  return result as never
 }
 // -----------------------------------------------------------------------------------------
 // DistributeOperation

src/type/engine/patterns/pattern.ts

@@ -28,33 +28,23 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import { type TUnreachable, Unreachable } from '../../../system/unreachable/index.ts'
-
 import { Guard } from '../../../guard/index.ts'
 import { type TSchema } from '../../types/schema.ts'
 import { type TPattern, Pattern } from '../../script/parser.ts'
 
-// ------------------------------------------------------------------
-// deno-coverage-ignore-start - symmetric unreachable
-//
-// Parser is parsing regular expression for strings and will return 
-// at least 1 TLiteral at a minumum.
-//
-// ------------------------------------------------------------------
-/** Parses a Pattern into a sequence of TemplateLiteral types */
+/** Parses a Pattern into a sequence of TemplateLiteral types. A result of [] indicates failure to parse. */
 export type TParsePatternIntoTypes<Pattern extends string,
   Parsed extends [TSchema[], string] | [] = TPattern<Pattern>,
   Result extends TSchema[] = Parsed extends [infer Types extends TSchema[], string] 
     ? Types 
-    : TUnreachable // []
+    : [] // Failed to Parse
 > = Result
-/** Parses a Pattern into a sequence of TemplateLiteral types */
+/** Parses a Pattern into a sequence of TemplateLiteral types. A result of [] indicates failure to parse. */
 export function ParsePatternIntoTypes<Pattern extends string>(pattern: Pattern): TParsePatternIntoTypes<Pattern> {
   const parsed = Pattern(pattern)
   const result = Guard.IsEqual(parsed.length, 2) 
     ? parsed[0] 
-    : Unreachable() // []
+    : [] // Failed to Parse
   return result as never
 }
-// deno-coverage-ignore-stop
 

src/type/engine/template-literal/decode.ts

@@ -31,13 +31,15 @@ THE SOFTWARE.
 import { TUnreachable, Unreachable } from '../../../system/unreachable/index.ts'
 import { Guard } from '../../../guard/index.ts'
 
+import { type TLiteral, type TLiteralValue, Literal, IsLiteral } from '../../types/literal.ts'
 import { type TSchema, IsSchema } from '../../types/schema.ts'
-import { type TUnion, Union, IsUnion } from '../../types/union.ts'
 import { type TString, String } from '../../types/string.ts'
-import { type TLiteral, type TLiteralValue, Literal, IsLiteral } from '../../types/literal.ts'
+import { type TTemplateLiteral } from '../../types/template-literal.ts'
+import { type TUnion, Union, IsUnion } from '../../types/union.ts'
 
 import { type TParsePatternIntoTypes, ParsePatternIntoTypes } from '../patterns/pattern.ts'
 import { type TTemplateLiteralFinite, TemplateLiteralFinite } from './finite.ts'
+import { TemplateLiteralCreate } from './create.ts'
 
 // ------------------------------------------------------------------
 // FromLiteral
@@ -176,19 +178,21 @@ function DecodeTypes<Types extends TSchema[]>(types: [...Types]): TDecodeTypes<T
 /** Decodes a TemplateLiteral into a Type. If the TemplateLiteral yields a non-finite set, the return value is TString */
 export type TTemplateLiteralDecode<Pattern extends string,
   Types extends TSchema[] = TParsePatternIntoTypes<Pattern>,
-  Finite extends boolean = TTemplateLiteralFinite<Types>,
   Result extends TSchema = (
-    Finite extends true 
-      ? TDecodeTypes<Types> 
-      : TString
+    Types extends []                            // Failed to Parse
+      ? TString
+      : TTemplateLiteralFinite<Types> extends true
+        ? TDecodeTypes<Types>
+        : TTemplateLiteral<Pattern>
   )
 > = Result
 /** Decodes a TemplateLiteral into a Type. If the TemplateLiteral yields a non-finite set, the return value is TString */
 export function TemplateLiteralDecode<Pattern extends string>(pattern: Pattern): TTemplateLiteralDecode<Pattern> {
   const types = ParsePatternIntoTypes(pattern)
-  const finite = TemplateLiteralFinite(types)
-  const result = finite 
-    ? DecodeTypes(types) 
-    : String()
+  const result = Guard.IsEqual(types.length, 0) // Failed to Parse
+    ? String()                                  // ... Pattern cannot be typed, so discard
+    : TemplateLiteralFinite(types)              
+      ? DecodeTypes(types)
+      : TemplateLiteralCreate(pattern)
   return result as never
 }

src/type/types/record.ts

@@ -40,6 +40,8 @@ import { type TDeferred, Deferred } from './deferred.ts'
 
 import { type TInstantiate, Instantiate } from '../engine/instantiate.ts'
 import { type TTemplateLiteralStatic } from '../engine/template-literal/index.ts'
+import { type TTemplateLiteralDecode, TemplateLiteralDecode } from '../engine/template-literal/decode.ts'
+
 import { CreateRecord } from '../engine/record/record-create.ts'
 
 // -------------------------------------------------------------------
@@ -127,18 +129,20 @@ export function RecordPattern<Type extends TRecord>(type: Type): TRecordPattern<
 export type TRecordKey<Type extends TRecord,
   Pattern extends string = TRecordPattern<Type>,
   Result extends TSchema = (
+    Pattern extends typeof StringKey ? TString :
     Pattern extends typeof IntegerKey ? TInteger :
     Pattern extends typeof NumberKey ? TNumber :
-    TString
+    TTemplateLiteralDecode<Pattern>
   )
 > = Result
 /** Returns the Record key as a TypeBox type  */
 export function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type> {
   const pattern = RecordPattern(type)
   const result = (
+    Guard.IsEqual(pattern, StringKey) ? String() :
     Guard.IsEqual(pattern, IntegerKey) ? Integer() :
     Guard.IsEqual(pattern, NumberKey) ? Number() :
-    String()
+    TemplateLiteralDecode(pattern)
   )
   return result as never
 }

tasks.ts

@@ -8,7 +8,7 @@ import { Range } from './task/range/index.ts'
 import { Metrics } from './task/metrics/index.ts'
 import { Task } from 'tasksmith'
 
-const Version = '1.0.75'
+const Version = '1.0.76'
 
 // ------------------------------------------------------------------
 // Build

test/typebox/runtime/type/engine/action/evaluate.ts

@@ -825,7 +825,6 @@ Test('Should Evaluate 66', () => {
   Assert.IsTrue(Type.IsBase(T.properties.value))
   Assert.IsTrue(T.properties.value instanceof Foo)
 })
-
 // ------------------------------------------------------------------
 // https://github.com/sinclairzx81/typebox/issues/1506
 // ------------------------------------------------------------------

test/typebox/runtime/type/engine/action/keyof.ts

@@ -1,5 +1,6 @@
 import { Assert } from 'test'
 import * as Type from 'typebox'
+import Guard from 'typebox/guard'
 
 const Test = Assert.Context('Type.Engine.KeyOf')
 
@@ -302,3 +303,19 @@ Test('Should KeyOf 26', () => {
   Assert.IsEqual(K.anyOf[0].const, 'x')
   Assert.IsEqual(K.anyOf[1].const, 'y')
 })
+// ------------------------------------------------------------------
+// Record with TemplateLiteral Key
+// ------------------------------------------------------------------
+Test('Should KeyOf 27', () => {
+  const K = Type.Record(Type.TemplateLiteral('x-${string}'), Type.Null())
+  const T: Type.TTemplateLiteral<'^x-.*$'> = Type.KeyOf(K)
+  Assert.IsTrue(Type.IsTemplateLiteral(T))
+  Assert.IsTrue(Guard.IsEqual(T.pattern, '^x-.*$'))
+})
+Test('Should KeyOf 28', () => {
+  const K = Type.Record(Type.TemplateLiteral('x-${1|2}'), Type.Null())
+  const T: Type.TUnion<[Type.TLiteral<'x-1'>, Type.TLiteral<'x-2'>]> = Type.KeyOf(K)
+  Assert.IsTrue(Type.IsUnion(T))
+  Assert.IsTrue(Guard.IsEqual(T.anyOf[0].const, 'x-1'))
+  Assert.IsTrue(Guard.IsEqual(T.anyOf[1].const, 'x-2'))
+})

test/typebox/runtime/type/engine/action/record.ts

@@ -366,7 +366,7 @@ Test('Should Record 24', () => {
   )
   Assert.IsEqual(Type.RecordPattern(T), '^(A|B).*$')
   Assert.IsTrue(Type.IsRecord(T))
-  Assert.IsTrue(Type.IsString(Type.RecordKey(T))) // observed as string
+  Assert.IsTrue(Type.IsTemplateLiteral(Type.RecordKey(T)))
   Assert.IsTrue(Type.IsNull(Type.RecordValue(T)))
 })
 // ------------------------------------------------------------------

test/typebox/runtime/type/engine/action/template-literal.ts

@@ -1,5 +1,6 @@
 import { Assert } from 'test'
 import * as Type from 'typebox'
+import Guard from 'typebox/guard'
 
 const Test = Assert.Context('Type.Engine.TemplateLiteral')
 
@@ -24,3 +25,33 @@ Test('Should TemplateLiteral 2', () => {
   Assert.IsEqual(Type.RecordPattern(R), '^$')
   Assert.IsTrue(Type.IsString(Type.RecordValue(R)))
 })
+// ------------------------------------------------------------------
+// Coverage: TemplateLiteralDecode
+// ------------------------------------------------------------------
+Test('Should TemplateLiteralDecode 1', () => {
+  const A: Type.TString = Type.TemplateLiteralDecode('')
+  Assert.IsTrue(Type.IsString(A))
+  Assert.IsFalse(Guard.HasPropertyKey(A, 'pattern')) // non-representable patterns are discarded
+})
+Test('Should TemplateLiteralDecode 2', () => {
+  const A: Type.TString = Type.TemplateLiteralDecode('x-.*$')
+  Assert.IsTrue(Type.IsString(A))
+})
+Test('Should TemplateLiteralDecode 3', () => {
+  const A: Type.TString = Type.TemplateLiteralDecode('^x-.*')
+  Assert.IsTrue(Type.IsString(A))
+})
+Test('Should TemplateLiteralDecode 4', () => {
+  const A: Type.TTemplateLiteral<'^x-.*$'> = Type.TemplateLiteralDecode('^x-.*$')
+  Assert.IsTrue(Type.IsTemplateLiteral(A))
+  Assert.IsTrue(Guard.IsEqual(A.pattern, '^x-.*$'))
+})
+Test('Should TemplateLiteralDecode 5', () => {
+  const A: Type.TUnion<[
+    Type.TLiteral<'x-1'>,
+    Type.TLiteral<'x-2'>
+  ]> = Type.TemplateLiteralDecode('^x-(1|2)$')
+  Assert.IsTrue(Type.IsUnion(A))
+  Assert.IsTrue(Guard.IsEqual(A.anyOf[0].const, 'x-1'))
+  Assert.IsTrue(Guard.IsEqual(A.anyOf[1].const, 'x-2'))
+})