Version 1.0.35 (#1396)

* Support Optional SemiColon | KeyOf Any Semantics

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.35](https://github.com/sinclairzx81/typebox/pull/1396)
+  - Support Optional SemiColon | KeyOf Any Semantics
 - [Revision 1.0.34](https://github.com/sinclairzx81/typebox/pull/1395)
   - Revert Dual Publishing due to TypeScript Playground Automatic Type Acquisition (ATA) Issue
 - [Revision 1.0.33](https://github.com/sinclairzx81/typebox/pull/1394)

design/syntax/syntax.ts

@@ -145,6 +145,13 @@ const GenericCall = Runtime.Tuple([
   Runtime.Ref('GenericCallArguments'),
 ])
 // ------------------------------------------------------------------
+// OptionalSemiColon
+// ------------------------------------------------------------------
+const OptionalSemiColon = Runtime.Union([
+  Runtime.Tuple([Runtime.Const(SemiColon)]),
+  Runtime.Tuple([])
+])
+// ------------------------------------------------------------------
 // Reference
 // ------------------------------------------------------------------
 const Reference = Runtime.Ident()
@@ -610,7 +617,8 @@ const Mapped = Runtime.Tuple([
   Runtime.Ref('MappedOptional'),
   Runtime.Const(Colon),
   Runtime.Ref('Type'),
-  Runtime.Const(RBrace)
+  Runtime.Ref('OptionalSemiColon'),
+  Runtime.Const(RBrace),
 ])
 // ------------------------------------------------------------------
 // Options
@@ -865,7 +873,8 @@ const ModuleDeclaration = Runtime.Tuple([
     Runtime.Ref('InterfaceDeclaration'),
     Runtime.Ref('TypeAliasDeclarationGeneric'),
     Runtime.Ref('TypeAliasDeclaration'),
-  ])
+  ]),
+  Runtime.Ref('OptionalSemiColon')
 ])
 // ------------------------------------------------------------------
 // Module
@@ -901,6 +910,8 @@ export const SyntaxModule = new Runtime.Module({
   GenericCallArguments,
   GenericCall,
 
+  OptionalSemiColon,
+
   KeywordString,
   KeywordNumber,
   KeywordBoolean,

src/type/engine/keyof/from-any.ts

@@ -0,0 +1,39 @@
+/*--------------------------------------------------------------------------
+
+TypeBox
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2025 Haydn Paterson 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+
+// deno-fmt-ignore-file
+
+import { type TNumber, Number } from '../../types/number.ts'
+import { type TString, String } from '../../types/string.ts'
+import { type TSymbol, Symbol } from '../../types/symbol.ts'
+import { type TUnion, Union } from '../../types/union.ts'
+
+export type TFromAny<Result = TUnion<[TNumber, TString, TSymbol]>> = Result
+export function FromAny(): TFromAny {
+  return Union([Number(), String(), Symbol()])
+}

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

@@ -29,7 +29,7 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 
 import { type TSchema } from '../../types/index.ts'
-import { type TNumber, Number } from "../../types/number.ts"
+import { type TNumber, Number } from '../../types/number.ts'
 
 export type TFromArray<_Type extends TSchema> = TNumber
 export function FromArray<_Type extends TSchema>(_type: _Type): TFromArray<_Type> {

src/type/engine/keyof/instantiate.ts

@@ -31,6 +31,7 @@ THE SOFTWARE.
 import { Memory } from '../../../system/memory/index.ts'
 import { type TSchema, type TSchemaOptions } from '../../types/schema.ts'
 import { type TProperties } from '../../types/properties.ts'
+import { type TAny, IsAny } from '../../types/any.ts'
 import { type TArray, IsArray } from '../../types/array.ts'
 import { type TCyclic, IsCyclic } from '../../types/cyclic.ts'
 import { type TIntersect, IsIntersect } from '../../types/intersect.ts'
@@ -47,7 +48,8 @@ import { type TCollapseToObject, CollapseToObject } from '../object/index.ts'
 // ------------------------------------------------------------------
 // Computed
 // ------------------------------------------------------------------
-import { type TFromArray, FromArray } from "./from-array.ts"
+import { type TFromAny, FromAny } from './from-any.ts'
+import { type TFromArray, FromArray } from './from-array.ts'
 import { type TFromObject, FromObject } from './from-object.ts'
 import { type TFromRecord, FromRecord } from './from-record.ts'
 import { type TFromTuple, FromTuple } from './from-tuple.ts'
@@ -80,17 +82,19 @@ function NormalizeType<Type extends TSchema>(type: Type): TNormalizeType<Type> {
 // Action
 // ------------------------------------------------------------------
 export type TKeyOfAction<Type extends TSchema, 
-  Normalized extends TSchema = TNormalizeType<Type>
+  Normal extends TSchema = TNormalizeType<Type>
 > = (
-  Normalized extends TArray<infer Type extends TSchema> ? TFromArray<Type> :
-  Normalized extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> :
-  Normalized extends TRecord ? TFromRecord<Normalized> :
-  Normalized extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> :
+  Normal extends TAny ? TFromAny :
+  Normal extends TArray<infer Type extends TSchema> ? TFromArray<Type> :
+  Normal extends TObject<infer Properties extends TProperties> ? TFromObject<Properties> :
+  Normal extends TRecord ? TFromRecord<Normal> :
+  Normal extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types> :
   TNever
 )
 export function KeyOfAction<Type extends TSchema>(type: Type): TKeyOfAction<Type> {
   const normal = NormalizeType(type)
   return (
+    IsAny(normal) ? FromAny() :
     IsArray(normal) ? FromArray(normal.items) :
     IsObject(normal) ? FromObject(normal.properties) :
     IsRecord(normal) ? FromRecord(normal) :

src/type/script/mapping.ts

@@ -246,6 +246,14 @@ export function GenericCallMapping(input: [unknown, unknown]): unknown {
   return IntrinsicOrCall(input[0] as string, input[1] as T.TSchema[])
 }
 // -------------------------------------------------------------------
+// OptionalSemiColon: [';'] | []
+// -------------------------------------------------------------------
+export type TOptionalSemiColonMapping<Input extends [unknown] | []>
+  = null
+export function OptionalSemiColonMapping(input: [unknown] | []): unknown {
+  return null
+}
+// -------------------------------------------------------------------
 // KeywordString: 'string'
 // -------------------------------------------------------------------
 export type TKeywordStringMapping<Input extends 'string'> = (
@@ -1149,16 +1157,16 @@ export function MappedAsMapping(input: [unknown, unknown] | []): unknown {
   return Guard.IsEqual(input.length, 2) ? [input[1]] : []
 }
 // -------------------------------------------------------------------
-// Mapped: ['{', MappedReadonly, '[', <Ident>, 'in', Type, MappedAs, ']', MappedOptional, ':', Type, '}']
+// Mapped: ['{', MappedReadonly, '[', <Ident>, 'in', Type, MappedAs, ']', MappedOptional, ':', Type, OptionalSemiColon, '}']
 // -------------------------------------------------------------------
-export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (
-  Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Union extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Type extends T.TSchema, '}']
+export type TMappedMapping<Input extends [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]> = (
+  Input extends ['{', infer Readonly extends TModifierOperation, '[', infer Key extends string, 'in', infer Union extends T.TSchema, infer As extends T.TSchema[], ']', infer Optional extends TModifierOperation, ':', infer Type extends T.TSchema, null, '}']
     ? (As extends [infer As extends T.TSchema]
       ? C.TMappedDeferred<T.TIdentifier<Key>, Union, As, TApplyReadonly<Readonly, TApplyOptional<Optional, Type>>>
       : C.TMappedDeferred<T.TIdentifier<Key>, Union, T.TRef<Key>, TApplyReadonly<Readonly, TApplyOptional<Optional, Type>>>
     ) : never
 )
-export function MappedMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]): unknown {
+export function MappedMapping(input: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown]): unknown {
   return (
     Guard.IsArray(input[6]) && Guard.IsEqual(input[6].length, 1)
       ? C.MappedDeferred(T.Identifier(input[3] as string), input[5] as T.TSchema, input[6][0] as T.TSchema, ApplyReadonly(input[1] as TModifierOperation, ApplyOptional(input[8] as TModifierOperation, input[10] as T.TSchema)))
@@ -1508,14 +1516,14 @@ export function ModuleDeclarationListMapping(input: [unknown, unknown]): unknown
   return PropertiesReduce(Delimited(input) as never)
 }
 // -------------------------------------------------------------------
-// ModuleDeclaration: [ExportKeyword, InterfaceDeclarationGeneric | InterfaceDeclaration | TypeAliasDeclarationGeneric | TypeAliasDeclaration]
+// ModuleDeclaration: [ExportKeyword, InterfaceDeclarationGeneric | InterfaceDeclaration | TypeAliasDeclarationGeneric | TypeAliasDeclaration, OptionalSemiColon]
 // -------------------------------------------------------------------
-export type TModuleDeclarationMapping<Input extends [unknown, unknown]> = (
-  Input extends [null, infer ModuleDeclaration extends T.TProperties]
+export type TModuleDeclarationMapping<Input extends [unknown, unknown, unknown]> = (
+  Input extends [null, infer ModuleDeclaration extends T.TProperties, null]
     ? ModuleDeclaration
     : never
 )
-export function ModuleDeclarationMapping(input: [unknown, unknown]): unknown {
+export function ModuleDeclarationMapping(input: [unknown, unknown, unknown]): unknown {
   return input[1] as T.TProperties
 }
 // -------------------------------------------------------------------