Version 1.0.80 (#1524)

* Retain Ref Options on Instantiate

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.80](https://github.com/sinclairzx81/typebox/pull/1524)
+  - Retain Ref Options on Instantiate
 - [Revision 1.0.79](https://github.com/sinclairzx81/typebox/pull/1518)
   - Fix IsMinLength String Check | 0-Length | No Enumeration
 - [Revision 1.0.78](https://github.com/sinclairzx81/typebox/pull/1514)

src/type/engine/instantiate.ts

@@ -344,7 +344,7 @@ export type TInstantiateType<Context extends TProperties, State extends TState,
   >,
   Type extends TSchema = Modifiers[0],
   Instantiated extends TSchema = (
-    Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Ref> :
+    Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> :
     Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> :
     Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> :
     Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> :
@@ -374,7 +374,7 @@ export function InstantiateType<Context extends TProperties, State extends TStat
     IsOptional(input) ? 'add' : 'none')
   const type = IsBase(modifiers[0]) ? modifiers[0].Clone() : modifiers[0]
   const instantiated = (
-    IsRef(type) ? RefInstantiate(context, state, type.$ref) :
+    IsRef(type) ? RefInstantiate(context, state, type, type.$ref) :
     IsArray(type) ? Array(InstantiateType(context, state, type.items), ArrayOptions(type)) :
     IsAsyncIterator(type) ? AsyncIterator(InstantiateType(context, state, type.iteratorItems), AsyncIteratorOptions(type)) :
     IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) :

src/type/engine/ref/instantiate.ts

@@ -29,28 +29,28 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 
 import { TProperties } from '../../types/properties.ts'
-import { type TRef, Ref } from '../../types/ref.ts'
 import { type TState, type TInstantiateType, InstantiateType } from '../instantiate.ts'
 import { type TCyclicCheck, CyclicCheck } from '../cyclic/check.ts'
+import { type TRef } from '../../types/ref.ts'
 
 // ------------------------------------------------------------------
 // Instantiate
 // ------------------------------------------------------------------
-export type TRefInstantiate<Context extends TProperties, State extends TState, Ref extends string> = (
+export type TRefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string> = (
   Ref extends keyof Context
     ? TCyclicCheck<[Ref], Context, Context[Ref]> extends true
-      ? TRef<Ref>
+      ? Type
       : TInstantiateType<Context, State, Context[Ref]>
-    : TRef<Ref>
+    : Type
 )
-export function RefInstantiate<Context extends TProperties, State extends TState, Ref extends string>
-  (context: Context, state: State, ref: Ref): 
-    TRefInstantiate<Context, State, Ref> {
+export function RefInstantiate<Context extends TProperties, State extends TState, Type extends TRef, Ref extends string>
+  (context: Context, state: State, type: Type, ref: Ref): 
+    TRefInstantiate<Context, State, Type, Ref> {
   return (
     ref in context
       ? CyclicCheck([ref], context, context[ref])
-        ? Ref(ref)
+        ? type
         : InstantiateType(context, state, context[ref])
-      : Ref(ref)
+      : type
   ) 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.79'
+const Version = '1.0.80'
 
 // ------------------------------------------------------------------
 // Build

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

@@ -9,24 +9,66 @@ Test('Should Ref 1', () => {
   const T: Type.TString = Type.Instantiate({ A }, R)
   Assert.IsTrue(Type.IsString(T))
 })
-Test('Should Ref 1', () => {
+Test('Should Ref 2', () => {
   const A = Type.String()
   const R = Type.Ref('B')
   const T: Type.TRef<'B'> = Type.Instantiate({ A }, R)
   Assert.IsTrue(Type.IsRef(T))
   Assert.IsEqual(T.$ref, 'B')
 })
-Test('Should Ref 1', () => {
+Test('Should Ref 3', () => {
   const A = Type.Ref('B')
   const B = Type.Ref('A')
   const T: Type.TRef<'A'> = Type.Instantiate({ A, B }, B)
   Assert.IsTrue(Type.IsRef(T))
   Assert.IsEqual(T.$ref, 'A')
 })
-Test('Should Ref 1', () => {
+Test('Should Ref 4', () => {
   const A = Type.Ref('B')
   const B = Type.Ref('A')
   const T: Type.TRef<'A'> = Type.Instantiate({ A, B }, B)
   Assert.IsTrue(Type.IsRef(T))
   Assert.IsEqual(T.$ref, 'A')
 })
+// ------------------------------------------------------------------
+// https://github.com/sinclairzx81/typebox/issues/1522
+//
+// Non-Instantiated Ref Must Retain Options
+// ------------------------------------------------------------------
+Test('Should Ref 5', () => {
+  const T: Type.TRef<'A'> = Type.Ref('A', { foo: 'bar' })
+  const S = Type.Instantiate({}, T) // no-target
+
+  Assert.IsTrue(Type.IsRef(S))
+  Assert.IsEqual(S.$ref, 'A')
+  Assert.HasPropertyKey(S, 'foo')
+  Assert.IsEqual(S.foo, 'bar')
+})
+Test('Should Ref 6', () => {
+  const T: Type.TRef<'A'> = Type.Ref('A', { foo: 'bar' })
+  const S: Type.TString = Type.Instantiate({ A: Type.String({ foo: 'baz' }) }, T)
+
+  Assert.IsTrue(Type.IsString(S))
+  Assert.HasPropertyKey(S, 'foo')
+  Assert.IsEqual(S.foo, 'baz')
+})
+Test('Should Ref 7', () => {
+  const R: Type.TRecord<'^.*$', Type.TRef<'A'>> = Type.Record(Type.String(), Type.Ref('A', { foo: 'bar' }))
+  const S: Type.TRecord<'^.*$', Type.TRef<'A'>> = Type.Instantiate({}, R) // no-target
+  const V: Type.TRef<'A'> = Type.RecordValue(S)
+
+  Assert.IsTrue(Type.IsRecord(S))
+  Assert.IsEqual(V.$ref, 'A')
+  Assert.HasPropertyKey(V, 'foo')
+  Assert.IsEqual(V.foo, 'bar')
+})
+Test('Should Ref 8', () => {
+  const R: Type.TRecord<'^.*$', Type.TRef<'A'>> = Type.Record(Type.String(), Type.Ref('A', { foo: 'bar' }))
+  const S: Type.TRecord<'^.*$', Type.TString> = Type.Instantiate({ A: Type.String({ foo: 'baz' }) }, R)
+  const V: Type.TString = Type.RecordValue(S)
+
+  Assert.IsTrue(Type.IsRecord(S))
+  Assert.IsTrue(Type.IsString(V))
+  Assert.HasPropertyKey(V, 'foo')
+  Assert.IsEqual(V.foo, 'baz')
+})