@sinclair/typebox 0.32.35 → 0.33.1

package/build/esm/type/indexed/indexed.mjs

@@ -1,7 +1,7 @@
+import { CreateType } from '../create/type.mjs';
 import { Never } from '../never/index.mjs';
 import { IntersectEvaluated } from '../intersect/index.mjs';
 import { UnionEvaluated } from '../union/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { IndexPropertyKeys } from './indexed-property-keys.mjs';
 import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 import { IndexFromMappedResult } from './indexed-from-mapped-result.mjs';
@@ -65,10 +65,14 @@ function FromSchema(T, K) {
     return (UnionEvaluated(IndexFromPropertyKeys(T, K)));
 }
 /** `[Json]` Returns an Indexed property type for the given keys */
-export function Index(T, K, options = {}) {
+export function Index(T, K, options) {
+    // mapped-types
+    if (IsMappedResult(K))
+        return IndexFromMappedResult(T, K, options);
+    if (IsMappedKey(K))
+        return IndexFromMappedKey(T, K, options);
     // prettier-ignore
-    return (IsMappedResult(K) ? CloneType(IndexFromMappedResult(T, K, options)) :
-        IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
-            IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
-                CloneType(FromSchema(T, K), options));
+    return CreateType(IsSchema(K)
+        ? FromSchema(T, IndexPropertyKeys(K))
+        : FromSchema(T, K), options);
 }

package/build/esm/type/instance-type/instance-type.mjs

@@ -1,5 +1,5 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-export function InstanceType(schema, options = {}) {
-    return CloneType(schema.returns, options);
+export function InstanceType(schema, options) {
+    return CreateType(schema.returns, options);
 }

package/build/esm/type/integer/integer.mjs

@@ -1,9 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates an Integer type */
-export function Integer(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Integer',
-        type: 'integer',
-    };
+export function Integer(options) {
+    return CreateType({ [Kind]: 'Integer', type: 'integer' }, options);
 }

package/build/esm/type/intersect/intersect-create.d.mts

@@ -1,3 +1,3 @@
 import type { TSchema } from '../schema/index.mjs';
 import type { TIntersect, IntersectOptions } from './intersect-type.mjs';
-export declare function IntersectCreate<T extends TSchema[]>(T: [...T], options: IntersectOptions): TIntersect<T>;
+export declare function IntersectCreate<T extends TSchema[]>(T: [...T], options?: IntersectOptions): TIntersect<T>;

package/build/esm/type/intersect/intersect-create.mjs

@@ -1,5 +1,5 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
-import { CloneType, CloneRest } from '../clone/type.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
@@ -8,12 +8,12 @@ import { IsObject, IsSchema } from '../guard/kind.mjs';
 // IntersectCreate
 // ------------------------------------------------------------------
 // prettier-ignore
-export function IntersectCreate(T, options) {
+export function IntersectCreate(T, options = {}) {
     const allObjects = T.every((schema) => IsObject(schema));
     const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties)
-        ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) }
+        ? { unevaluatedProperties: options.unevaluatedProperties }
         : {};
-    return ((options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects
-        ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
-        : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) }));
+    return CreateType((options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects
+        ? { ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: T }
+        : { ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: T }), options);
 }

package/build/esm/type/intersect/intersect-evaluated.mjs

@@ -1,5 +1,5 @@
 import { OptionalKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { Never } from '../never/index.mjs';
 import { Optional } from '../optional/index.mjs';
@@ -31,7 +31,7 @@ export function IntersectEvaluated(T, options = {}) {
     if (T.length === 0)
         return Never(options);
     if (T.length === 1)
-        return CloneType(T[0], options);
+        return CreateType(T[0], options);
     if (T.some((schema) => IsTransform(schema)))
         throw new Error('Cannot intersect transform types');
     return ResolveIntersect(T, options);

package/build/esm/type/intersect/intersect.mjs

@@ -1,4 +1,4 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Never } from '../never/index.mjs';
 import { IntersectCreate } from './intersect-create.mjs';
 // ------------------------------------------------------------------
@@ -6,11 +6,11 @@ import { IntersectCreate } from './intersect-create.mjs';
 // ------------------------------------------------------------------
 import { IsTransform } from '../guard/kind.mjs';
 /** `[Json]` Creates an evaluated Intersect type */
-export function Intersect(T, options = {}) {
+export function Intersect(T, options) {
     if (T.length === 0)
         return Never(options);
     if (T.length === 1)
-        return CloneType(T[0], options);
+        return CreateType(T[0], options);
     if (T.some((schema) => IsTransform(schema)))
         throw new Error('Cannot intersect transform types');
     return IntersectCreate(T, options);

package/build/esm/type/intrinsic/intrinsic-from-mapped-key.mjs

@@ -1,17 +1,19 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Intrinsic } from './intrinsic.mjs';
 import { Literal } from '../literal/index.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function MappedIntrinsicPropertyKey(K, M, options) {
     return {
-        [K]: Intrinsic(Literal(K), M, options)
+        [K]: Intrinsic(Literal(K), M, Clone(options))
     };
 }
 // prettier-ignore
 function MappedIntrinsicPropertyKeys(K, M, options) {
-    return K.reduce((Acc, L) => {
+    const result = K.reduce((Acc, L) => {
         return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
     }, {});
+    return result;
 }
 // prettier-ignore
 function MappedIntrinsicProperties(T, M, options) {

package/build/esm/type/intrinsic/intrinsic.mjs

@@ -1,3 +1,4 @@
+import { CreateType } from '../create/type.mjs';
 import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralExpressionFinite, TemplateLiteralExpressionGenerate } from '../template-literal/index.mjs';
 import { IntrinsicFromMappedKey } from './intrinsic-from-mapped-key.mjs';
 import { Literal } from '../literal/index.mjs';
@@ -55,8 +56,9 @@ export function Intrinsic(schema, mode, options = {}) {
     // Intrinsic-Mapped-Inference
     IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) :
         // Standard-Inference
-        IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, schema) :
+        IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, options) :
             IsUnion(schema) ? Union(FromRest(schema.anyOf, mode), options) :
                 IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) :
-                    schema);
+                    // Default Type
+                    CreateType(schema, options));
 }

package/build/esm/type/iterator/iterator.mjs

@@ -1,11 +1,6 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[JavaScript]` Creates an Iterator type */
-export function Iterator(items, options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Iterator',
-        type: 'Iterator',
-        items: CloneType(items),
-    };
+export function Iterator(items, options) {
+    return CreateType({ [Kind]: 'Iterator', type: 'Iterator', items }, options);
 }

package/build/esm/type/keyof/keyof-from-mapped-result.d.mts

@@ -8,5 +8,5 @@ type TFromProperties<K extends TProperties> = ({
 });
 type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
 export type TKeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function KeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
+export declare function KeyOfFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/esm/type/keyof/keyof-from-mapped-result.mjs

@@ -1,10 +1,11 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { KeyOf } from './keyof.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromProperties(K, options) {
     const Acc = {};
     for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-        Acc[K2] = KeyOf(K[K2], options);
+        Acc[K2] = KeyOf(K[K2], Clone(options));
     return Acc;
 }
 // prettier-ignore

package/build/esm/type/keyof/keyof.mjs

@@ -1,8 +1,8 @@
+import { CreateType } from '../create/type.mjs';
 import { Literal } from '../literal/index.mjs';
 import { Number } from '../number/index.mjs';
 import { KeyOfPropertyKeys } from './keyof-property-keys.mjs';
 import { UnionEvaluated } from '../union/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { KeyOfFromMappedResult } from './keyof-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
@@ -13,7 +13,7 @@ export function KeyOfPropertyKeysToRest(T) {
     return T.map(L => L === '[number]' ? Number() : Literal(L));
 }
 /** `[Json]` Creates a KeyOf type */
-export function KeyOf(T, options = {}) {
+export function KeyOf(T, options) {
     if (IsMappedResult(T)) {
         return KeyOfFromMappedResult(T, options);
     }
@@ -21,6 +21,6 @@ export function KeyOf(T, options = {}) {
         const K = KeyOfPropertyKeys(T);
         const S = KeyOfPropertyKeysToRest(K);
         const U = UnionEvaluated(S);
-        return CloneType(U, options);
+        return CreateType(U, options);
     }
 }

package/build/esm/type/literal/literal.mjs

@@ -1,10 +1,10 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Literal type */
-export function Literal(value, options = {}) {
-    return {
-        ...options,
+export function Literal(value, options) {
+    return CreateType({
         [Kind]: 'Literal',
         const: value,
         type: typeof value,
-    };
+    }, options);
 }

package/build/esm/type/mapped/mapped-key.mjs

@@ -1,8 +1,9 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 // prettier-ignore
 export function MappedKey(T) {
-    return {
+    return CreateType({
         [Kind]: 'MappedKey',
         keys: T
-    };
+    });
 }

package/build/esm/type/mapped/mapped-result.mjs

@@ -1,8 +1,9 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 // prettier-ignore
 export function MappedResult(properties) {
-    return {
+    return CreateType({
         [Kind]: 'MappedResult',
         properties
-    };
+    });
 }

package/build/esm/type/mapped/mapped.mjs

@@ -1,5 +1,4 @@
 import { Kind, OptionalKind, ReadonlyKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 // evaluation types
 import { Array } from '../array/index.mjs';
@@ -93,9 +92,9 @@ export function MappedFunctionReturnType(K, T) {
     return Acc;
 }
 /** `[Json]` Creates a Mapped object type */
-export function Mapped(key, map, options = {}) {
+export function Mapped(key, map, options) {
     const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
     const RT = map({ [Kind]: 'MappedKey', keys: K });
     const R = MappedFunctionReturnType(K, RT);
-    return CloneType(Object(R), options);
+    return Object(R, options);
 }

package/build/esm/type/never/never.mjs

@@ -1,9 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Never type */
-export function Never(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Never',
-        not: {},
-    };
+export function Never(options) {
+    return CreateType({ [Kind]: 'Never', not: {} }, options);
 }

package/build/esm/type/not/not.d.mts

@@ -7,4 +7,4 @@ export interface TNot<T extends TSchema = TSchema> extends TSchema {
     not: T;
 }
 /** `[Json]` Creates a Not type */
-export declare function Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
+export declare function Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T>;

package/build/esm/type/not/not.mjs

@@ -1,10 +1,6 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Not type */
-export function Not(schema, options) {
-    return {
-        ...options,
-        [Kind]: 'Not',
-        not: CloneType(schema),
-    };
+export function Not(not, options) {
+    return CreateType({ [Kind]: 'Not', not }, options);
 }

package/build/esm/type/null/null.mjs

@@ -1,9 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Null type */
-export function Null(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Null',
-        type: 'null',
-    };
+export function Null(options) {
+    return CreateType({ [Kind]: 'Null', type: 'null' }, options);
 }

package/build/esm/type/number/number.mjs

@@ -1,9 +1,6 @@
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 /** `[Json]` Creates a Number type */
-export function Number(options = {}) {
-    return {
-        ...options,
-        [Kind]: 'Number',
-        type: 'number',
-    };
+export function Number(options) {
+    return CreateType({ [Kind]: 'Number', type: 'number' }, options);
 }

package/build/esm/type/object/object.mjs

@@ -1,21 +1,22 @@
-import { CloneType } from '../clone/type.mjs';
+import { CreateType } from '../create/type.mjs';
 import { Kind } from '../symbols/index.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-import { IsOptional, IsSchema } from '../guard/kind.mjs';
+import { IsOptional } from '../guard/kind.mjs';
+function RequiredKeys(properties) {
+    const keys = [];
+    for (let key in properties) {
+        if (!IsOptional(properties[key]))
+            keys.push(key);
+    }
+    return keys;
+}
 /** `[Json]` Creates an Object type */
-function _Object(properties, options = {}) {
-    const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
-    const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]));
-    const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
-    const clonedAdditionalProperties = IsSchema(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
-    const clonedProperties = {};
-    for (const key of propertyKeys)
-        clonedProperties[key] = CloneType(properties[key]);
-    return (requiredKeys.length > 0
-        ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
-        : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties });
+function _Object(properties, options) {
+    const required = RequiredKeys(properties);
+    const schematic = required.length > 0 ? { [Kind]: 'Object', type: 'object', properties, required } : { [Kind]: 'Object', type: 'object', properties };
+    return CreateType(schematic, options);
 }
 /** `[Json]` Creates an Object type */
 export const Object = _Object;

package/build/esm/type/omit/omit-from-mapped-key.d.mts

@@ -8,5 +8,5 @@ type TFromPropertyKey<T extends TSchema, K extends PropertyKey> = {
 type TFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>> : Acc);
 type TFromMappedKey<T extends TSchema, K extends TMappedKey> = (TFromPropertyKeys<T, K['keys']>);
 export type TOmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>> = (TMappedResult<P>);
-export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+export declare function OmitFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/esm/type/omit/omit-from-mapped-key.mjs

@@ -1,9 +1,10 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Omit } from './omit.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromPropertyKey(T, K, options) {
     return {
-        [K]: Omit(T, [K], options)
+        [K]: Omit(T, [K], Clone(options))
     };
 }
 // prettier-ignore

package/build/esm/type/omit/omit-from-mapped-result.d.mts

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
 });
 type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
 export type TOmitFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function OmitFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P>;
+export declare function OmitFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/esm/type/omit/omit-from-mapped-result.mjs

@@ -1,10 +1,11 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Omit } from './omit.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromProperties(P, K, options) {
     const Acc = {};
     for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-        Acc[K2] = Omit(P[K2], K, options);
+        Acc[K2] = Omit(P[K2], K, Clone(options));
     return Acc;
 }
 // prettier-ignore

package/build/esm/type/omit/omit.mjs

@@ -1,10 +1,10 @@
+import { CreateType } from '../create/type.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { OmitFromMappedKey } from './omit-from-mapped-key.mjs';
 import { OmitFromMappedResult } from './omit-from-mapped-result.mjs';
 // ------------------------------------------------------------------
@@ -41,7 +41,7 @@ function OmitResolve(T, K) {
             IsObject(T) ? Object(FromProperties(T.properties, K)) :
                 Object({}));
 }
-export function Omit(T, K, options = {}) {
+export function Omit(T, K, options) {
     // mapped
     if (IsMappedKey(K))
         return OmitFromMappedKey(T, K, options);
@@ -50,6 +50,6 @@ export function Omit(T, K, options = {}) {
     // non-mapped
     const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
     const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(OmitResolve(T, I), options);
-    return { ...D, ...R };
+    const R = OmitResolve(T, I);
+    return CreateType({ ...D, ...R }, options);
 }

package/build/esm/type/optional/optional.mjs

@@ -1,13 +1,13 @@
+import { CreateType } from '../create/type.mjs';
 import { OptionalKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { Discard } from '../discard/index.mjs';
 import { OptionalFromMappedResult } from './optional-from-mapped-result.mjs';
 import { IsMappedResult } from '../guard/kind.mjs';
 function RemoveOptional(schema) {
-    return Discard(CloneType(schema), [OptionalKind]);
+    return CreateType(Discard(schema, [OptionalKind]));
 }
 function AddOptional(schema) {
-    return { ...CloneType(schema), [OptionalKind]: 'Optional' };
+    return CreateType({ ...schema, [OptionalKind]: 'Optional' });
 }
 // prettier-ignore
 function OptionalWithFlag(schema, F) {

package/build/esm/type/parameters/parameters.mjs

@@ -1,6 +1,5 @@
 import { Tuple } from '../tuple/index.mjs';
-import { CloneRest } from '../clone/type.mjs';
 /** `[JavaScript]` Extracts the Parameters from the given Function type */
-export function Parameters(schema, options = {}) {
-    return Tuple(CloneRest(schema.parameters), { ...options });
+export function Parameters(schema, options) {
+    return Tuple(schema.parameters, options);
 }

package/build/esm/type/partial/partial-from-mapped-result.d.mts

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties> = ({
 });
 type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
 export type TPartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
-export declare function PartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options: SchemaOptions): TMappedResult<P>;
+export declare function PartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/esm/type/partial/partial-from-mapped-result.mjs

@@ -1,10 +1,11 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Partial } from './partial.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromProperties(K, options) {
     const Acc = {};
     for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-        Acc[K2] = Partial(K[K2], options);
+        Acc[K2] = Partial(K[K2], Clone(options));
     return Acc;
 }
 // prettier-ignore

package/build/esm/type/partial/partial.mjs

@@ -1,10 +1,10 @@
+import { CreateType } from '../create/type.mjs';
 import { Optional } from '../optional/index.mjs';
 import { Object } from '../object/index.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { PartialFromMappedResult } from './partial-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
@@ -32,10 +32,10 @@ function PartialResolve(T) {
                 Object({}));
 }
 /** `[Json]` Constructs a type where all properties are optional */
-export function Partial(T, options = {}) {
+export function Partial(T, options) {
     if (IsMappedResult(T))
         return PartialFromMappedResult(T, options);
     const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(PartialResolve(T), options);
-    return { ...D, ...R };
+    const R = PartialResolve(T);
+    return CreateType({ ...options, ...D, ...R });
 }

package/build/esm/type/pick/pick-from-mapped-key.d.mts

@@ -8,5 +8,5 @@ type TFromPropertyKey<T extends TSchema, K extends PropertyKey> = {
 type TFromPropertyKeys<T extends TSchema, K extends PropertyKey[], Acc extends TProperties = {}> = (K extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<T, RK, Acc & TFromPropertyKey<T, LK>> : Acc);
 type TFromMappedKey<T extends TSchema, K extends TMappedKey> = (TFromPropertyKeys<T, K['keys']>);
 export type TPickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>> = (TMappedResult<P>);
-export declare function PickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options: SchemaOptions): TMappedResult<P>;
+export declare function PickFromMappedKey<T extends TSchema, K extends TMappedKey, P extends TProperties = TFromMappedKey<T, K>>(T: T, K: K, options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/esm/type/pick/pick-from-mapped-key.mjs

@@ -1,9 +1,10 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Pick } from './pick.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromPropertyKey(T, K, options) {
     return {
-        [K]: Pick(T, [K], options)
+        [K]: Pick(T, [K], Clone(options))
     };
 }
 // prettier-ignore

package/build/esm/type/pick/pick-from-mapped-result.d.mts

@@ -8,5 +8,5 @@ type TFromProperties<P extends TProperties, K extends PropertyKey[]> = ({
 });
 type TFromMappedResult<R extends TMappedResult, K extends PropertyKey[]> = (Evaluate<TFromProperties<R['properties'], K>>);
 export type TPickFromMappedResult<T extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<T, K>> = (Ensure<TMappedResult<P>>);
-export declare function PickFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options: SchemaOptions): TMappedResult<P>;
+export declare function PickFromMappedResult<R extends TMappedResult, K extends PropertyKey[], P extends TProperties = TFromMappedResult<R, K>>(R: R, K: [...K], options?: SchemaOptions): TMappedResult<P>;
 export {};

package/build/esm/type/pick/pick-from-mapped-result.mjs

@@ -1,10 +1,11 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Pick } from './pick.mjs';
+import { Clone } from '../clone/value.mjs';
 // prettier-ignore
 function FromProperties(P, K, options) {
     const Acc = {};
     for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-        Acc[K2] = Pick(P[K2], K, options);
+        Acc[K2] = Pick(P[K2], K, Clone(options));
     return Acc;
 }
 // prettier-ignore

package/build/esm/type/pick/pick.mjs

@@ -1,10 +1,10 @@
+import { CreateType } from '../create/type.mjs';
 import { Intersect } from '../intersect/index.mjs';
 import { Union } from '../union/index.mjs';
 import { Object } from '../object/index.mjs';
 import { IndexPropertyKeys } from '../indexed/index.mjs';
 import { Discard } from '../discard/index.mjs';
 import { TransformKind } from '../symbols/index.mjs';
-import { CloneType } from '../clone/type.mjs';
 import { PickFromMappedKey } from './pick-from-mapped-key.mjs';
 import { PickFromMappedResult } from './pick-from-mapped-result.mjs';
 // ------------------------------------------------------------------
@@ -36,7 +36,7 @@ function PickResolve(T, K) {
             IsObject(T) ? Object(FromProperties(T.properties, K)) :
                 Object({}));
 }
-export function Pick(T, K, options = {}) {
+export function Pick(T, K, options) {
     // mapped
     if (IsMappedKey(K))
         return PickFromMappedKey(T, K, options);
@@ -45,6 +45,6 @@ export function Pick(T, K, options = {}) {
     // non-mapped
     const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
     const D = Discard(T, [TransformKind, '$id', 'required']);
-    const R = CloneType(PickResolve(T, I), options);
-    return { ...D, ...R };
+    const R = PickResolve(T, I);
+    return CreateType({ ...D, ...R }, options);
 }