Version 1.0.33 (#1394)

* Re-Enable Dual Publishing

* Pick Update | Migration Guide

* Import Manifest

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0-migration.md

@@ -6,14 +6,14 @@ This document covers upgrading from TypeBox 0.34.x to 1.0. While most of the API
 
 ## Contents
 
-- [ESM Package](#ESM)
 - [Kind, Hint, ReadonlyKind and OptionalKind](#Symbols)
 - [Type.Date and Type.Uint8Array](#Globals)
 - [Type.Recursive](#Recursive)
 - [Type.RegExp](#RegExp)
 - [Type.Composite](#Composite)
 - [Type.Transform](#Transform)
 - [Type.Const](#Const)
+- [Type.Pick and Type.Omit](#PickOmit)
 - [TypeCompiler](#TypeCompiler)
 - [References](#References)
 - [FormatRegistry](#FormatRegistry)
@@ -24,12 +24,6 @@ This document covers upgrading from TypeBox 0.34.x to 1.0. While most of the API
 - [SetErrorFunction](#SetErrorFunction)
 - [CustomErrors](#CustomErrors)
 
-<a name="ESM"></a>
-
-## ESM Package
-
-Version 1.0 is published as an ESM-only package. Users will need to ensure their environments support ESM module resolution.
-
 <a name="Symbols"></a>
 
 ## Kind, Hint, ReadonlyKind and OptionalKind
@@ -273,6 +267,46 @@ const S = Type.Script({ T }, `{
                                                     // }>
 ```
 
+<a name="PickOmit"></a>
+
+## Type.Pick and Type.Omit
+
+Version 1.0 updates Pick and Omit to return evaluated Object types when applied to Union and Intersect types. This change aligns with V1’s ability to evaluate logical type expressions for mapped types. As a consequence, the return structures of Pick and Omit may vary depending on the source type being used.
+
+In 0.34.x, Pick and Omit would simply traverse a logical type expression and select properties from embedded Object types. In 1.0, Pick and Omit evaluate the result into a normalized Object type. Both 0.34.x and 1.0 return semantically equivalent types, but in 1.0 the result is reduced to its simplest form.
+
+### Fallback
+
+[Pick](/example/legacy/pick.ts) | [Omit](/example/legacy/omit.ts)
+
+### Example
+
+0.34.x
+
+```typescript
+const X = Type.Object({ x: Type.Number(), z: Type.Number() })
+const Y = Type.Object({ y: Type.Number(), z: Type.Literal(1) })
+const Z = Type.Intersect([X, Y])
+
+const T = Type.Pick(Z, ['z'])                       // const T: TIntersect<[TObject<{
+                                                    //   z: TNumber;
+                                                    // }>, TObject<{
+                                                    //   z: TLiteral<1>
+                                                    // }>]>
+```
+
+1.0.0
+
+```typescript
+const X = Type.Object({ x: Type.Number(), z: Type.Number() })
+const Y = Type.Object({ y: Type.Number(), z: Type.Literal(1) })
+const Z = Type.Intersect([X, Y])
+
+const T = Type.Pick(Z, ['z'])                       // const T: Type.TObject<{
+                                                    //   z: Type.TLiteral<1>;
+                                                    // }>
+```
+
 
 <a name="TypeCompiler"></a>
 

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.33](https://github.com/sinclairzx81/typebox/pull/1394)
+  - Re-Enable Dual Publishing for ESM and CommonJS
 - [Revision 1.0.32](https://github.com/sinclairzx81/typebox/pull/1393)
   - Fix Object Collapse Evaluator for Overlapping Properties (Pick, Omit and Index)
 - [Revision 1.0.31](https://github.com/sinclairzx81/typebox/pull/1390)

deno.jsonc

@@ -20,7 +20,7 @@
     // --------------------------------------------------------------
     // Build
     // --------------------------------------------------------------
-    "tasksmith": "https://raw.githubusercontent.com/sinclairzx81/tasksmith/0.9.2/src/index.ts",
+    "tasksmith": "https://raw.githubusercontent.com/sinclairzx81/tasksmith/0.9.5/src/index.ts",
     "parsebox": "https://raw.githubusercontent.com/sinclairzx81/parsebox/0.11.0/src/index.ts",
     // --------------------------------------------------------------
     // Test

deno.lock

@@ -269,7 +269,7 @@ const Extends = Runtime.Union([
 const Base = Runtime.Union([
   Runtime.Tuple([Runtime.Const(LParen), Runtime.Ref('Type'), Runtime.Const(RParen)]),
   Runtime.Ref('Keyword'),
-  Runtime.Ref('Object'),
+  Runtime.Ref('_Object_'),
   Runtime.Ref('Tuple'),
   Runtime.Ref('TemplateLiteral'),
   Runtime.Ref('Literal'),
@@ -426,7 +426,7 @@ const Properties = Runtime.Tuple([
 // ------------------------------------------------------------------
 // Object
 // ------------------------------------------------------------------
-const Object = Runtime.Ref('Properties')
+const _Object_ = Runtime.Ref('Properties')
 // ------------------------------------------------------------------
 // ElementNamed
 // ------------------------------------------------------------------
@@ -954,7 +954,7 @@ export const SyntaxModule = new Runtime.Module({
   PropertyDelimiter,
   PropertyList,
   Properties,
-  Object,
+  _Object_,
 
   ElementNamed,
   ElementReadonlyOptional,

design/syntax/syntax.ts

@@ -33,25 +33,36 @@ import { Guard } from '../../../guard/index.ts'
 import { type TSchema } from '../../types/schema.ts'
 import { type TProperties } from '../../types/properties.ts'
 import { type TFromType, FromType } from './from-type.ts'
+import { type TEvaluateIntersect, EvaluateIntersect } from '../evaluate/evaluate.ts'
 
 // ------------------------------------------------------------------
 // CollapseProperties
 // ------------------------------------------------------------------
 type TCollapseIntersectProperties<Left extends TProperties, Right extends TProperties,
   LeftKeys extends keyof Left = Exclude<keyof Left, keyof Right>,
   RightKeys extends keyof Right = Exclude<keyof Right, keyof Left>,
+  SharedKeys extends keyof Left & keyof Right = Extract<keyof Left, keyof Right>,
+
   LeftProperties extends TProperties = { [Key in LeftKeys]: Left[Key] },
   RightProperties extends TProperties = { [Key in RightKeys]: Right[Key] },
-  Result extends TProperties = Memory.TAssign<LeftProperties, RightProperties>
-> = Result
+  SharedProperties extends TProperties = { [Key in SharedKeys]: TEvaluateIntersect<[Left[Key], Right[Key]]> },
+
+  Unique extends TProperties = Memory.TAssign<LeftProperties, RightProperties>,
+  Shared extends TProperties = Memory.TAssign<Unique, SharedProperties>
+> = Shared
 
 function CollapseIntersectProperties<Left extends TProperties, Right extends TProperties>(left: Left, right: Right): TCollapseIntersectProperties<Left, Right> {
   const leftKeys = Guard.Keys(left).filter((key) => !Guard.HasPropertyKey(right, key))
   const rightKeys = Guard.Keys(right).filter((key) => !Guard.HasPropertyKey(left, key))
-  const leftProperties = leftKeys.reduce((result, key) => Memory.Assign(result, { [key]: left[key] }), {})
-  const rightProperties = rightKeys.reduce((result, key) => Memory.Assign(result, { [key]: right[key] }), {})
-  const result = Memory.Assign(leftProperties, rightProperties)
-  return result as never
+  const sharedKeys = Guard.Keys(left).filter((key) => Guard.HasPropertyKey(right, key))
+
+  const leftProperties = leftKeys.reduce((result, key) => ({ ...result, [key]: left[key] }), {})
+  const rightProperties = rightKeys.reduce((result, key) => ({ ...result, [key]: right[key] }), {})
+  const sharedProperties = sharedKeys.reduce((result, key) => ({ ...result, [key]: EvaluateIntersect([left[key], right[key]]) }), {})
+
+  const unique = Memory.Assign(leftProperties, rightProperties)
+  const shared = Memory.Assign(unique, sharedProperties)
+  return shared as never
 }
 // ------------------------------------------------------------------
 // Intersect

src/type/engine/object/from-intersect.ts

@@ -519,7 +519,7 @@ export function ExtendsMapping(input: [unknown, unknown, unknown, unknown, unkno
     : []
 }
 // -------------------------------------------------------------------
-// Base: ['(', Type, ')'] | Keyword | Object | Tuple | TemplateLiteral | Literal | Constructor | Function | Mapped | Options | GenericCall | Reference
+// Base: ['(', Type, ')'] | Keyword | _Object_ | Tuple | TemplateLiteral | Literal | Constructor | Function | Mapped | Options | GenericCall | Reference
 // -------------------------------------------------------------------
 export type TBaseMapping<Input extends [unknown, unknown, unknown] | unknown> = (
   Input extends ['(', infer Type extends T.TSchema, ')'] ? Type :
@@ -881,14 +881,14 @@ export function PropertiesMapping(input: [unknown, unknown, unknown]): unknown {
   return PropertiesReduce(input[1] as T.TProperties[])
 }
 // -------------------------------------------------------------------
-// Object: Properties
+// _Object_: Properties
 // -------------------------------------------------------------------
-export type TObjectMapping<Input extends unknown> = (
+export type T_Object_Mapping<Input extends unknown> = (
   Input extends [infer Properties extends T.TProperties, infer _PatternProperties extends T.TProperties]
   ? T.TObject<Properties>
   : never
 )
-export function ObjectMapping(input: unknown): unknown {
+export function _Object_Mapping(input: unknown): unknown {
   const [properties, patternProperties] = input as [T.TProperties, T.TProperties]
   const options = Guard.IsEqual(Guard.Keys(patternProperties).length, 0) ? {} : { patternProperties }
   return T.Object(properties, options)