Version 1.1.12 (#1555)

* Intrinsic Length Property Indexer

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.1.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.1.12](https://github.com/sinclairzx81/typebox/pull/1555)
+  - Intrinsic Length Property Indexer for Tuple and Array types.
 - [Revision 1.1.11](https://github.com/sinclairzx81/typebox/pull/1553)
   - Linear Scan for Common Formats | 2020-12 Spec Alignment
 - [Revision 1.1.10](https://github.com/sinclairzx81/typebox/pull/1552)

src/type/engine/indexed/from-array.ts

@@ -28,6 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
+import { Guard } from '../../../guard/index.ts'
 import { type TSchema } from '../../types/schema.ts'
 import { type TIntersect, Intersect, IsIntersect  } from '../../types/intersect.ts'
 import { type TUnion, Union, IsUnion } from '../../types/union.ts'
@@ -83,12 +84,27 @@ export function NormalizeIndexer<Type extends TSchema>(type: Type): TNormalizeIn
 export type TFromArray<Type extends TSchema, Indexer extends TSchema,
   NormalizedIndexer extends TSchema = TNormalizeIndexer<Indexer>,
   Check extends ExtendsResult.TResult = TExtends<{}, NormalizedIndexer, TNumber>,
-  Result extends TSchema = Check extends ExtendsResult.TExtendsTrueLike ? Type : TNever
-> = Result
+  Result extends TSchema = (
+    // indexer
+    Check extends ExtendsResult.TExtendsTrueLike 
+      ? Type
+      // length (intrinsic)
+      : Indexer extends TLiteral<infer _ extends 'length'>
+        ? TNumber
+        : TNever
+  )> = Result
 export function FromArray<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer): TFromArray<Type, Indexer> {
   const normalizedIndexer = NormalizeIndexer(indexer)
   const check = Extends({}, normalizedIndexer, Number())
-  const result = ExtendsResult.IsExtendsTrueLike(check) ? type : Never()
+  const result = (
+    // indexer
+    ExtendsResult.IsExtendsTrueLike(check) 
+      ? type
+      // length (intrinsic)
+      : IsLiteral(indexer) && Guard.IsEqual(indexer.const, 'length')
+        ? Number()
+        : Never()
+  )
   return result as never
 }
 

src/type/engine/indexed/from-tuple.ts

@@ -28,8 +28,9 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
+import { Guard } from '../../../guard/index.ts'
 import { type TSchema } from '../../types/schema.ts'
-import { type TLiteral, Literal } from '../../types/literal.ts'
+import { type TLiteral, Literal, IsLiteral } from '../../types/literal.ts'
 import { type TNumber, IsNumber } from '../../types/number.ts'
 import { type TInteger, IsInteger } from '../../types/integer.ts'
 
@@ -80,16 +81,23 @@ function FromTupleWithoutIndexer<Types extends TSchema[]>(types: [...Types]): TF
 // ------------------------------------------------------------------
 export type TFromTuple<Types extends TSchema[], Indexer extends TSchema,
   Result extends TSchema = (
-    Indexer extends TNumber | TInteger
-      ? TFromTupleWithoutIndexer<Types>
-      : TFromTupleWithIndexer<Types, Indexer>
+    // length (intrinsic)
+    Indexer extends TLiteral<infer _ extends 'length'>
+      ? TLiteral<Types['length']>
+      // indexer
+      : Indexer extends TNumber | TInteger
+        ? TFromTupleWithoutIndexer<Types>
+        : TFromTupleWithIndexer<Types, Indexer>
   )
 > = Result
 export function FromTuple<Types extends TSchema[], Indexer extends TSchema>(types: [...Types], indexer: Indexer): TFromTuple<Types, Indexer> {
-  
   return (
-    IsNumber(indexer) || IsInteger(indexer)
-      ? FromTupleWithoutIndexer(types)
-      : FromTupleWithIndexer(types, indexer)
+    // length (intrinsic)
+    IsLiteral(indexer) && Guard.IsEqual(indexer.const, 'length')
+      ? Literal(types.length)
+      // indexer
+      : IsNumber(indexer) || IsInteger(indexer)
+        ? FromTupleWithoutIndexer(types)
+        : FromTupleWithIndexer(types, indexer)
   ) 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.1.11'
+const Version = '1.1.12'
 
 // ------------------------------------------------------------------
 // Build

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

@@ -471,3 +471,21 @@ Test('Should Index 35', () => {
   Assert.IsTrue(Type.IsNumber(K.anyOf[0]))
   Assert.IsTrue(Type.IsString(K.anyOf[1]))
 })
+// ------------------------------------------------------------------
+// Length
+// ------------------------------------------------------------------
+Test('Should Index 36', () => {
+  const T = Type.Tuple([
+    Type.Literal(1),
+    Type.Literal(2),
+    Type.Literal(3)
+  ])
+  const S: Type.TLiteral<3> = Type.Index(T, Type.Literal('length'))
+  Assert.IsTrue(Type.IsLiteral(S))
+  Assert.IsEqual(S.const, 3)
+})
+Test('Should Index 37', () => {
+  const T = Type.Array(Type.String())
+  const S: Type.TNumber = Type.Index(T, Type.Literal('length'))
+  Assert.IsTrue(Type.IsNumber(S))
+})

test/typebox/runtime/type/script/indexed.ts

@@ -62,3 +62,17 @@ Test('Should Indexed 10', () => {
   const T: Type.TNumber = Type.Instantiate({ A: Type.Script(`{ x: number }`) }, R)
   Assert.IsTrue(Type.IsNumber(T))
 })
+// ------------------------------------------------------------------
+// Length
+// ------------------------------------------------------------------
+Test('Should Indexed 11', () => {
+  const T = Type.Script(`[1, 2, 3]`)
+  const S: Type.TLiteral<3> = Type.Script({ T }, `T['length']`)
+  Assert.IsTrue(Type.IsLiteral(S))
+  Assert.IsEqual(S.const, 3)
+})
+Test('Should Indexed 12', () => {
+  const T = Type.Script(`string[]`)
+  const S: Type.TNumber = Type.Script({ T }, `T['length']`)
+  Assert.IsTrue(Type.IsNumber(S))
+})