typebox - npm Package Compare versions

Comparing version 1.2.4 to 1.2.5

build/type/action/module.d.mts

 import { type TSchemaOptions } from '../types/schema.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
-import { type TInstantiate } from '../engine/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
+import { type TModuleInstantiate } from '../engine/module/instantiate.mjs';
 /** Creates a deferred Module action. */
-export type TModuleDeferred<Context extends TProperties> = (TDeferred<'Module', [Context]>);
+export type TModuleDeferred<Declarations extends TProperties> = (TDeferred<'Module', [Declarations]>);
 /** Creates a deferred Module action. */
-export declare function ModuleDeferred<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModuleDeferred<Context>;
-/** Applies a Module transformation action to the embedded property types. */
-export type TModule<Context extends TProperties> = (TInstantiate<{}, TModuleDeferred<Context>>);
-/** Applies a Module transformation action to the embedded property types. */
-export declare function Module<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModule<Context>;
+export declare function ModuleDeferred<Declarations extends TProperties>(declarations: Declarations, options?: TSchemaOptions): TModuleDeferred<Declarations>;
+/** Creates a Module with the given declarations */
+export type TModule<Declarations extends TProperties> = (TModuleInstantiate<{}, TState<[], []>, Declarations>);
+/** Creates a Module with the given declarations */
+export declare function Module<Declarations extends TProperties>(declarations: Declarations, options?: TSchemaOptions): TModule<Declarations>;

build/type/action/module.mjs

 // deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
-import { Instantiate } from '../engine/instantiate.mjs';
+import { State } from '../engine/instantiate.mjs';
+import { ModuleInstantiate } from '../engine/module/instantiate.mjs';
 /** Creates a deferred Module action. */
-export function ModuleDeferred(context, options = {}) {
-    return Deferred('Module', [context], options);
+export function ModuleDeferred(declarations, options = {}) {
+    return Deferred('Module', [declarations], options);
 }
-/** Applies a Module transformation action to the embedded property types. */
-export function Module(context, options = {}) {
-    return Instantiate({}, ModuleDeferred(context, options));
+/** Creates a Module with the given declarations */
+export function Module(declarations, options = {}) {
+    return ModuleInstantiate({}, State([], []), declarations, options);
 }

build/type/engine/instantiate.d.mts

@@ -134,3 +134,3 @@ import { type TSchema } from '../types/schema.mjs';
     Parameters
-] extends ['Module', [infer Properties extends TProperties]] ? TModuleInstantiate<Context, State, Properties> : [
+] extends ['Module', [infer Declarations extends TProperties]] ? TModuleInstantiate<Context, State, Declarations> : [
     Action,
@@ -137,0 +137,0 @@ Parameters

build/type/engine/module/instantiate.d.mts

@@ -8,13 +8,13 @@ import { Memory } from '../../../system/memory/index.mjs';
 import { type TInstantiateType } from '../instantiate.mjs';
-type TInstantiateCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
-    [Key in Extract<keyof Context, CyclicKeys[number]>]: TInstantiateCyclic<Context, Key, Context[Key]>;
+type TInstantiateCyclics<Context extends TProperties, Declarations extends TProperties, CyclicKeys extends string[], DeclarationContext extends TProperties = Memory.TAssign<Context, Declarations>, Result extends TProperties = {
+    [Key in Extract<keyof Declarations, CyclicKeys[number]>]: TInstantiateCyclic<DeclarationContext, Key, Declarations[Key]>;
 }> = Result;
-type TInstantiateNonCyclics<Context extends TProperties, CyclicKeys extends string[], Result extends TProperties = {
-    [Key in Exclude<keyof Context, CyclicKeys[number]>]: TInstantiateType<Context, TState<[], []>, Context[Key]>;
+type TInstantiateNonCyclics<Context extends TProperties, Declarations extends TProperties, CyclicKeys extends string[], DeclarationContext extends TProperties = Memory.TAssign<Context, Declarations>, Result extends TProperties = {
+    [Key in Exclude<keyof Declarations, CyclicKeys[number]>]: TInstantiateType<DeclarationContext, TState<[], []>, Declarations[Key]>;
 }> = Result;
-type TInstantiateModule<Context extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Context>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
+type TInstantiateModule<Context extends TProperties, Declarations extends TProperties, CyclicCandidates extends string[] = TCyclicCandidates<Declarations>, InstantiatedCyclics extends TProperties = TInstantiateCyclics<Context, Declarations, CyclicCandidates>, InstantiatedNonCyclics extends TProperties = TInstantiateNonCyclics<Context, Declarations, CyclicCandidates>, InstantiatedModule extends TProperties = InstantiatedCyclics & InstantiatedNonCyclics> = {
     [Key in keyof InstantiatedModule]: InstantiatedModule[Key];
 } & {};
-export type TModuleInstantiate<Context extends TProperties, _State extends TState, Properties extends TProperties, ModuleContext extends TProperties = Memory.TAssign<Context, Properties>, InstantiatedModule extends TProperties = TInstantiateModule<ModuleContext>> = InstantiatedModule;
-export declare function ModuleInstantiate<Context extends TProperties, State extends TState, Properties extends TProperties>(context: Context, _state: State, properties: Properties, options: TSchemaOptions): TModuleInstantiate<Context, State, Properties>;
+export type TModuleInstantiate<Context extends TProperties, _State extends TState, Declarations extends TProperties, InstantiatedModule extends TProperties = TInstantiateModule<Context, Declarations>> = InstantiatedModule;
+export declare function ModuleInstantiate<Context extends TProperties, State extends TState, Declarations extends TProperties>(context: Context, _state: State, declarations: Declarations, options: TSchemaOptions): TModuleInstantiate<Context, State, Declarations>;
 export {};

build/type/engine/module/instantiate.mjs

@@ -12,25 +12,26 @@ // deno-lint-ignore-file ban-types
 import { InstantiateType } from '../instantiate.mjs';
-function InstantiateCyclics(context, cyclicKeys) {
-    const keys = Guard.Keys(context).filter(key => cyclicKeys.includes(key));
-    return keys.reduce((result, key) => {
-        return { ...result, [key]: InstantiateCyclic(context, key, context[key]) };
+function InstantiateCyclics(context, declarations, cyclicKeys) {
+    const declarationContext = Memory.Assign(context, declarations);
+    const declarationKeys = Guard.Keys(declarations).filter(key => cyclicKeys.includes(key));
+    return declarationKeys.reduce((result, key) => {
+        return { ...result, [key]: InstantiateCyclic(declarationContext, key, declarations[key]) };
     }, {});
 }
-function InstantiateNonCyclics(context, cyclicKeys) {
-    const keys = Guard.Keys(context).filter(key => !cyclicKeys.includes(key));
-    return keys.reduce((result, key) => {
-        return { ...result, [key]: InstantiateType(context, State([], []), context[key]) };
+function InstantiateNonCyclics(context, declarations, cyclicKeys) {
+    const declarationContext = Memory.Assign(context, declarations);
+    const declarationKeys = Guard.Keys(declarations).filter(key => !cyclicKeys.includes(key));
+    return declarationKeys.reduce((result, key) => {
+        return { ...result, [key]: InstantiateType(declarationContext, State([], []), declarations[key]) };
     }, {});
 }
-function InstantiateModule(context, options) {
-    const cyclicCandidates = CyclicCandidates(context);
-    const instantiatedCyclics = InstantiateCyclics(context, cyclicCandidates);
-    const instantiatedNonCyclics = InstantiateNonCyclics(context, cyclicCandidates);
+function InstantiateModule(context, declarations, options) {
+    const cyclicCandidates = CyclicCandidates(declarations);
+    const instantiatedCyclics = InstantiateCyclics(context, declarations, cyclicCandidates);
+    const instantiatedNonCyclics = InstantiateNonCyclics(context, declarations, cyclicCandidates);
     const instantiatedModule = { ...instantiatedCyclics, ...instantiatedNonCyclics };
     return Memory.Update(instantiatedModule, {}, options);
 }
-export function ModuleInstantiate(context, _state, properties, options) {
-    const moduleContext = Memory.Assign(context, properties);
-    const instantiatedModule = InstantiateModule(moduleContext, options);
+export function ModuleInstantiate(context, _state, declarations, options) {
+    const instantiatedModule = InstantiateModule(context, declarations, options);
     return instantiatedModule;
 }

package.json

 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "keywords": [
@@ -6,0 +6,0 @@ "typescript",

No alert changes

Improved metrics

Total package byte prevSize

1499636

0.05%

Lines of code

17125

0.01%

No dependency changes