Version 1.0.46 (#1432)

* Readonly

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.46](https://github.com/sinclairzx81/typebox/pull/1432)
+  - Add ReadonlyType Utility Type (mirroring TypeScript `Readonly<T>`)
 - [Revision 1.0.45](https://github.com/sinclairzx81/typebox/pull/1431)
   - Fix for Codec Inference. Prevent Recursive `~codec` keyword matching.
 - [Revision 1.0.44](https://github.com/sinclairzx81/typebox/pull/1420)

design/website/docs/type/partial.md

@@ -1,21 +1,17 @@
 # Partial
 
-Makes all properties of an Object optional.
+This type is an alias for the `Partial<T>` TypeScript utility type. It makes all properties of an Object optional.
 
 ## Example
 
 Example usage is shown below.
 
 ```typescript
-const T = Type.Object({                             // const T = {
-  x: Type.Number(),                                 //   type: 'object',
-  y: Type.Number(),                                 //   required: ['x', 'y', 'z'],
-  z: Type.Number()                                  //   properties: {
-})                                                  //     x: { type: 'number' },
-                                                    //     y: { type: 'number' },
-                                                    //     z: { type: 'number' }
-                                                    //   }
-                                                    // }
+const T = Type.Object({                             // const T: TObject<{
+  x: Type.Number(),                                 //   x: TNumber,
+  y: Type.Number(),                                 //   y: TNumber,
+  z: Type.Number()                                  //   z: TNumber
+})                                                  // }>
 
 const S = Type.Partial(T)                           // const S: TObject<{
                                                     //   x: TOptional<TNumber>,

design/website/docs/type/readonly-type.md

@@ -0,0 +1,37 @@
+# ReadonlyType
+
+This type is an alias for the `Readonly<T>` TypeScript utility type. It makes all properties of an Object `readonly` or marks an Array or Tuple as immutable `readonly T[]`.
+
+## Example
+
+When applied to a Object, each property of the Object will be marked as `TReadonly<T>`
+
+```typescript
+const T = Type.Object({                             // const T = TObject<{
+  x: Type.Number(),                                 //   x: TNumber,
+  y: Type.Number(),                                 //   y: TNumber,
+  z: Type.Number()                                  //   z: TNumber,
+})                                                  // }>
+
+const S = Type.ReadonlyType(T)                      // const S: TObject<{
+                                                    //   x: TReadonly<TNumber>,
+                                                    //   y: TReadonly<TNumber>,
+                                                    //   z: TReadonly<TNumber>
+                                                    // }>
+```
+
+When applied to an Array or Tuple, the type is marked as `TImmutable<T>`
+
+```typescript
+const T = Type.Tuple([                              // const T = TImmutable<TTuple<[
+  Type.Number(),                                    //   TNumber,
+  Type.String(),                                    //   TString
+])                                                  // ]>>
+
+const S = Type.ReadonlyType(T)                      // const S: TImmutable<TTuple<[
+                                                    //   TNumber,
+                                                    //   TString
+                                                    // }>>
+
+type S = Type.Static<typeof S>                      // type S = readonly [number, string]
+```

docs/docs/type/partial.html

@@ -1,16 +1,12 @@
 <h1>Partial</h1>
-<p>Makes all properties of an Object optional.</p>
+<p>This type is an alias for the <code>Partial&lt;T&gt;</code> TypeScript utility type. It makes all properties of an Object optional.</p>
 <h2>Example</h2>
 <p>Example usage is shown below.</p>
-<pre><code class="language-typescript">const T = Type.Object({                             // const T = {
-  x: Type.Number(),                                 //   type: &#39;object&#39;,
-  y: Type.Number(),                                 //   required: [&#39;x&#39;, &#39;y&#39;, &#39;z&#39;],
-  z: Type.Number()                                  //   properties: {
-})                                                  //     x: { type: &#39;number&#39; },
-                                                    //     y: { type: &#39;number&#39; },
-                                                    //     z: { type: &#39;number&#39; }
-                                                    //   }
-                                                    // }
+<pre><code class="language-typescript">const T = Type.Object({                             // const T: TObject&lt;{
+  x: Type.Number(),                                 //   x: TNumber,
+  y: Type.Number(),                                 //   y: TNumber,
+  z: Type.Number()                                  //   z: TNumber
+})                                                  // }&gt;
 
 const S = Type.Partial(T)                           // const S: TObject&lt;{
                                                     //   x: TOptional&lt;TNumber&gt;,

docs/docs/type/readonly-type.html

@@ -0,0 +1,29 @@
+<h1>ReadonlyType</h1>
+<p>This type is an alias for the <code>Readonly&lt;T&gt;</code> TypeScript utility type. It makes all properties of an Object <code>readonly</code> or marks an Array or Tuple as immutable <code>readonly T[]</code>.</p>
+<h2>Example</h2>
+<p>When applied to a Object, each property of the Object will be marked as <code>TReadonly&lt;T&gt;</code></p>
+<pre><code class="language-typescript">const T = Type.Object({                             // const T = TObject&lt;{
+  x: Type.Number(),                                 //   x: TNumber,
+  y: Type.Number(),                                 //   y: TNumber,
+  z: Type.Number()                                  //   z: TNumber,
+})                                                  // }&gt;
+
+const S = Type.ReadonlyType(T)                      // const S: TObject&lt;{
+                                                    //   x: TReadonly&lt;TNumber&gt;,
+                                                    //   y: TReadonly&lt;TNumber&gt;,
+                                                    //   z: TReadonly&lt;TNumber&gt;
+                                                    // }&gt;
+</code></pre>
+<p>When applied to an Array or Tuple, the type is marked as <code>TImmutable&lt;T&gt;</code></p>
+<pre><code class="language-typescript">const T = Type.Tuple([                              // const T = TImmutable&lt;TTuple&lt;[
+  Type.Number(),                                    //   TNumber,
+  Type.String(),                                    //   TString
+])                                                  // ]&gt;&gt;
+
+const S = Type.ReadonlyType(T)                      // const S: TImmutable&lt;TTuple&lt;[
+                                                    //   TNumber,
+                                                    //   TString
+                                                    // }&gt;&gt;
+
+type S = Type.Static&lt;typeof S&gt;                      // type S = readonly [number, string]
+</code></pre>

docs/manifest.json

@@ -102,6 +102,7 @@
     "partial": "docs/type/partial.html",
     "pick": "docs/type/pick.html",
     "promise": "docs/type/promise.html",
+    "readonly-type": "docs/type/readonly-type.html",
     "readonly": "docs/type/readonly.html",
     "record": "docs/type/record.html",
     "ref": "docs/type/ref.html",

src/type/action/index.ts

@@ -48,6 +48,7 @@ export * from './options.ts'
 export * from './parameters.ts'
 export * from './partial.ts'
 export * from './pick.ts'
+export * from './readonly-type.ts'
 export * from './required.ts'
 export * from './return-type.ts'
 export * from './uncapitalize.ts'

src/type/action/readonly-type.ts

@@ -0,0 +1,56 @@
+/*--------------------------------------------------------------------------
+
+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 TSchema, type TSchemaOptions } from '../types/schema.ts'
+import { type TDeferred, Deferred } from '../types/deferred.ts'
+import { type TInstantiate, Instantiate } from '../engine/instantiate.ts'
+
+// ------------------------------------------------------------------
+// Deferred
+// ------------------------------------------------------------------
+/** Creates a deferred ReadonlyType action. */
+export type TReadonlyTypeDeferred<Type extends TSchema> = (
+  TDeferred<'ReadonlyType', [Type]>
+)
+/** Creates a deferred ReadonlyType action. */
+export function ReadonlyTypeDeferred<Type extends TSchema>(type: Type, options: TSchemaOptions = {}) {
+  return Deferred('ReadonlyType', [type], options)
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
+export type TReadonlyType<Type extends TSchema> = (
+  TInstantiate<{}, TReadonlyTypeDeferred<Type>>
+)
+/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
+export function ReadonlyType<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TReadonlyType<Type> {
+  return Instantiate({}, ReadonlyTypeDeferred(type, options)) as never
+}

src/type/engine/index.ts

@@ -58,6 +58,7 @@ export * from './parameters/index.ts'
 export * from './patterns/index.ts'
 export * from './partial/index.ts'
 export * from './pick/index.ts'
+export * from './readonly-type/index.ts'
 export * from './record/index.ts'
 export * from './ref/index.ts'
 export * from './required/index.ts'

src/type/engine/instantiate.ts

@@ -90,6 +90,7 @@ import { type TOptionsInstantiate, OptionsInstantiate } from './options/instanti
 import { type TParametersInstantiate, ParametersInstantiate } from './parameters/instantiate.ts'
 import { type TPartialInstantiate, PartialInstantiate } from './partial/instantiate.ts'
 import { type TPickInstantiate, PickInstantiate } from './pick/instantiate.ts'
+import { type TReadonlyTypeInstantiate, ReadonlyTypeInstantiate } from './readonly-type/instantiate.ts'
 import { type TRecordInstantiate, RecordInstantiate } from './record/instantiate.ts'
 import { type TRefInstantiate, RefInstantiate } from './ref/instantiate.ts'
 import { type TRequiredInstantiate, RequiredInstantiate } from './required/instantiate.ts'
@@ -288,6 +289,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
   [Action, Parameters] extends ['Parameters', [infer Type extends TSchema]] ? TParametersInstantiate<Context, State, Type> :
   [Action, Parameters] extends ['Partial', [infer Type extends TSchema]] ? TPartialInstantiate<Context, State, Type> :
   [Action, Parameters] extends ['Omit', [infer Type extends TSchema, infer Indexer extends TSchema]] ? TOmitInstantiate<Context, State, Type, Indexer> :
+  [Action, Parameters] extends ['ReadonlyType', [infer Type extends TSchema]] ? TReadonlyTypeInstantiate<Context, State, Type> :
   [Action, Parameters] extends ['Record', [infer Key extends TSchema, infer Value extends TSchema]] ? TRecordInstantiate<Context, State, Key, Value> :
   [Action, Parameters] extends ['Required', [infer Type extends TSchema]] ? TRequiredInstantiate<Context, State, Type> :
   [Action, Parameters] extends ['ReturnType', [infer Type extends TSchema]] ? TReturnTypeInstantiate<Context, State, Type> :
@@ -320,6 +322,7 @@ function InstantiateDeferred<Context extends TProperties, State extends TState,
     Guard.IsEqual(action, 'Parameters') ? ParametersInstantiate(context, state, parameters[0], options) :
     Guard.IsEqual(action, 'Partial') ? PartialInstantiate(context, state, parameters[0], options) :
     Guard.IsEqual(action, 'Omit') ? OmitInstantiate(context, state, parameters[0], parameters[1], options) :
+    Guard.IsEqual(action, 'ReadonlyType') ? ReadonlyTypeInstantiate(context, state, parameters[0], options) :
     Guard.IsEqual(action, 'Record') ? RecordInstantiate(context, state, parameters[0], parameters[1], options) :
     Guard.IsEqual(action, 'Required') ? RequiredInstantiate(context, state, parameters[0], options) :
     Guard.IsEqual(action, 'ReturnType') ? ReturnTypeInstantiate(context, state, parameters[0], options) :