@sinclair/typebox 0.32.0-dev-13 → 0.32.0-dev-15

package/build/require/type/extends/index.d.ts

@@ -1,5 +1,5 @@
 export * from './extends-check';
-export * from './extends-mapped-result-from-result';
-export * from './extends-mapped-result';
+export * from './extends-from-mapped-key';
+export * from './extends-from-mapped-result';
 export * from './extends-undefined';
 export * from './extends';

package/build/require/type/extends/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./extends-check"), exports);
-__exportStar(require("./extends-mapped-result-from-result"), exports);
-__exportStar(require("./extends-mapped-result"), exports);
+__exportStar(require("./extends-from-mapped-key"), exports);
+__exportStar(require("./extends-from-mapped-result"), exports);
 __exportStar(require("./extends-undefined"), exports);
 __exportStar(require("./extends"), exports);

package/build/require/type/extract/extract-from-mapped-result.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TExtract } from './extract';
+type FromProperties<K extends TProperties, U extends TSchema> = ({
+    [K2 in keyof K]: TExtract<K[K2], U>;
+});
+declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
+type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
+declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
+export type TExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
+export declare function ExtractFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+export {};

package/build/require/type/extract/extract-from-mapped-result.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractFromMappedResult = void 0;
+const index_1 = require("../mapped/index");
+const extract_1 = require("./extract");
+function FromProperties(K, U, options) {
+    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: (0, extract_1.Extract)(K[K2], U, options) };
+    }, {});
+}
+function FromMappedResult(K, U, options) {
+    return FromProperties(K.properties, U, options);
+}
+function ExtractFromMappedResult(T, U, options) {
+    const P = FromMappedResult(T, U, options);
+    return (0, index_1.MappedResult)(P);
+}
+exports.ExtractFromMappedResult = ExtractFromMappedResult;

package/build/require/type/extract/extract.d.ts

@@ -1,10 +1,12 @@
 import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Assert, AssertRest, AssertType, UnionToTuple } from '../helpers/index';
+import type { TMappedResult } from '../mapped/index';
 import { type TTemplateLiteral } from '../template-literal/index';
 import { type TLiteral } from '../literal/index';
 import { type TUnion } from '../union/index';
 import { type Static } from '../static/index';
 import { UnionResolve } from '../union/index';
+import { type TExtractFromMappedResult } from './extract-from-mapped-result';
 type FromTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
@@ -15,5 +17,6 @@ type FromArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple
 export type ExtractResolve<T extends TSchema, U extends TSchema> = (T extends TTemplateLiteral ? FromTemplateLiteral<T, U> : T extends TUnion<infer S> ? FromArray<S, U> : T extends U ? T : T);
 export declare function ExtractResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExtractResolve<L, R>;
 export type TExtract<T extends TSchema, U extends TSchema> = ExtractResolve<T, U>;
+export declare function Extract<L extends TMappedResult, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtractFromMappedResult<L, R>;
 export declare function Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
 export {};

package/build/require/type/extract/extract.js

@@ -6,6 +6,7 @@ const index_2 = require("../union/index");
 const index_3 = require("../never/index");
 const index_4 = require("../extends/index");
 const type_1 = require("../clone/type");
+const extract_from_mapped_result_1 = require("./extract-from-mapped-result");
 const type_2 = require("../guard/type");
 function ExtractResolve(L, R) {
     return ((0, type_2.TTemplateLiteral)(L) ? ExtractResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
@@ -19,7 +20,12 @@ function ExtractResolve(L, R) {
 }
 exports.ExtractResolve = ExtractResolve;
 function Extract(type, union, options = {}) {
-    const E = ExtractResolve(type, union);
-    return (0, type_1.CloneType)(E, options);
+    if ((0, type_2.TMappedResult)(type)) {
+        return (0, extract_from_mapped_result_1.ExtractFromMappedResult)(type, union, options);
+    }
+    else {
+        const E = ExtractResolve(type, union);
+        return (0, type_1.CloneType)(E, options);
+    }
 }
 exports.Extract = Extract;

package/build/require/type/extract/index.d.ts

@@ -1 +1,2 @@
+export * from './extract-from-mapped-result';
 export * from './extract';

package/build/require/type/extract/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./extract-from-mapped-result"), exports);
 __exportStar(require("./extract"), exports);

package/build/require/type/guard/type.d.ts

@@ -14,7 +14,7 @@ import type { TFunction } from '../function/index';
 import type { TInteger } from '../integer/index';
 import type { TIntersect } from '../intersect/index';
 import type { TIterator } from '../iterator/index';
-import type { TLiteral } from '../literal/index';
+import type { TLiteral, TLiteralValue } from '../literal/index';
 import type { TMappedKey, TMappedResult } from '../mapped/index';
 import type { TNever } from '../never/index';
 import type { TNot } from '../not/index';
@@ -37,56 +37,57 @@ import type { TDate } from '../date/index';
 import type { TThis } from '../recursive/index';
 export declare class TypeGuardUnknownTypeError extends Error {
 }
-export declare function TReadonly<T extends TSchema>(schema: T): schema is TReadonly<T>;
-export declare function TOptional<T extends TSchema>(schema: T): schema is TOptional<T>;
-export declare function TAny(schema: unknown): schema is TAny;
-export declare function TArray(schema: unknown): schema is TArray;
-export declare function TAsyncIterator(schema: unknown): schema is TAsyncIterator;
-export declare function TBigInt(schema: unknown): schema is TBigInt;
-export declare function TBoolean(schema: unknown): schema is TBoolean;
-export declare function TConstructor(schema: unknown): schema is TConstructor;
-export declare function TDate(schema: unknown): schema is TDate;
-export declare function TFunction(schema: unknown): schema is TFunction;
-export declare function TInteger(schema: unknown): schema is TInteger;
-export declare function TProperties(schema: unknown): schema is TProperties;
-export declare function TIntersect(schema: unknown): schema is TIntersect;
-export declare function TIterator(schema: unknown): schema is TIterator;
-export declare function TKindOf<T extends string>(schema: unknown, kind: T): schema is Record<PropertyKey, unknown> & {
+export declare function TReadonly<T extends TSchema>(value: T): value is TReadonly<T>;
+export declare function TOptional<T extends TSchema>(value: T): value is TOptional<T>;
+export declare function TAny(value: unknown): value is TAny;
+export declare function TArray(value: unknown): value is TArray;
+export declare function TAsyncIterator(value: unknown): value is TAsyncIterator;
+export declare function TBigInt(value: unknown): value is TBigInt;
+export declare function TBoolean(value: unknown): value is TBoolean;
+export declare function TConstructor(value: unknown): value is TConstructor;
+export declare function TDate(value: unknown): value is TDate;
+export declare function TFunction(value: unknown): value is TFunction;
+export declare function TInteger(value: unknown): value is TInteger;
+export declare function TProperties(value: unknown): value is TProperties;
+export declare function TIntersect(value: unknown): value is TIntersect;
+export declare function TIterator(value: unknown): value is TIterator;
+export declare function TKindOf<T extends string>(value: unknown, kind: T): value is Record<PropertyKey, unknown> & {
     [Kind]: T;
 };
-export declare function TLiteralString(schema: unknown): schema is TLiteral<string>;
-export declare function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
-export declare function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
-export declare function TLiteral(schema: unknown): schema is TLiteral;
-export declare function TMappedKey(schema: unknown): schema is TMappedKey;
-export declare function TMappedResult(schema: unknown): schema is TMappedResult;
-export declare function TNever(schema: unknown): schema is TNever;
-export declare function TNot(schema: unknown): schema is TNot;
-export declare function TNull(schema: unknown): schema is TNull;
-export declare function TNumber(schema: unknown): schema is TNumber;
-export declare function TObject(schema: unknown): schema is TObject;
-export declare function TPromise(schema: unknown): schema is TPromise;
-export declare function TRecord(schema: unknown): schema is TRecord;
-export declare function TRecursive(schema: unknown): schema is {
+export declare function TLiteralString(value: unknown): value is TLiteral<string>;
+export declare function TLiteralNumber(value: unknown): value is TLiteral<number>;
+export declare function TLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+export declare function TLiteral(value: unknown): value is TLiteral;
+export declare function TLiteralValue(value: unknown): value is TLiteralValue;
+export declare function TMappedKey(value: unknown): value is TMappedKey;
+export declare function TMappedResult(value: unknown): value is TMappedResult;
+export declare function TNever(value: unknown): value is TNever;
+export declare function TNot(value: unknown): value is TNot;
+export declare function TNull(value: unknown): value is TNull;
+export declare function TNumber(value: unknown): value is TNumber;
+export declare function TObject(value: unknown): value is TObject;
+export declare function TPromise(value: unknown): value is TPromise;
+export declare function TRecord(value: unknown): value is TRecord;
+export declare function TRecursive(value: unknown): value is {
     [Hint]: 'Recursive';
 };
-export declare function TRef(schema: unknown): schema is TRef;
-export declare function TString(schema: unknown): schema is TString;
-export declare function TSymbol(schema: unknown): schema is TSymbol;
-export declare function TTemplateLiteral(schema: unknown): schema is TTemplateLiteral<TTemplateLiteralKind[]>;
-export declare function TThis(schema: unknown): schema is TThis;
-export declare function TTransform(schema: unknown): schema is {
+export declare function TRef(value: unknown): value is TRef;
+export declare function TString(value: unknown): value is TString;
+export declare function TSymbol(value: unknown): value is TSymbol;
+export declare function TTemplateLiteral(value: unknown): value is TTemplateLiteral<TTemplateLiteralKind[]>;
+export declare function TThis(value: unknown): value is TThis;
+export declare function TTransform(value: unknown): value is {
     [TransformKind]: TransformOptions;
 };
-export declare function TTuple(schema: unknown): schema is TTuple;
-export declare function TUndefined(schema: unknown): schema is TUndefined;
-export declare function TUnionLiteral(schema: unknown): schema is TUnion<TLiteral[]>;
-export declare function TUnion(schema: unknown): schema is TUnion;
-export declare function TUint8Array(schema: unknown): schema is TUint8Array;
-export declare function TUnknown(schema: unknown): schema is TUnknown;
-export declare function TUnsafe(schema: unknown): schema is TUnsafe<unknown>;
-export declare function TVoid(schema: unknown): schema is TVoid;
-export declare function TKind(schema: unknown): schema is Record<PropertyKey, unknown> & {
+export declare function TTuple(value: unknown): value is TTuple;
+export declare function TUndefined(value: unknown): value is TUndefined;
+export declare function TUnionLiteral(value: unknown): value is TUnion<TLiteral[]>;
+export declare function TUnion(value: unknown): value is TUnion;
+export declare function TUint8Array(value: unknown): value is TUint8Array;
+export declare function TUnknown(value: unknown): value is TUnknown;
+export declare function TUnsafe(value: unknown): value is TUnsafe<unknown>;
+export declare function TVoid(value: unknown): value is TVoid;
+export declare function TKind(value: unknown): value is Record<PropertyKey, unknown> & {
     [Kind]: string;
 };
-export declare function TSchema(schema: unknown): schema is TSchema;
+export declare function TSchema(value: unknown): value is TSchema;