@valbuild/core 0.43.0 → 0.43.1

package/dist/declarations/src/index.d.ts

@@ -1,9 +1,9 @@
 export { initVal } from "./initVal.js";
 export type { InitVal, ValConfig, ValConstructor } from "./initVal.js";
-export { Schema, type SerializedSchema } from "./schema/index.js";
+export { Schema, type SerializedSchema, type SelectorOfSchema } from "./schema/index.js";
 export type { ImageMetadata } from "./schema/image.js";
 export type { LinkSource } from "./source/link.js";
-export type { ValModule, SerializedModule } from "./module.js";
+export type { ValModule, SerializedModule, InferValModuleType } from "./module.js";
 export type { SourceObject, SourcePrimitive, Source } from "./source/index.js";
 export type { FileSource } from "./source/file.js";
 export type { RawString } from "./schema/string.js";

package/dist/declarations/src/initSchema.d.ts

@@ -28,10 +28,10 @@ export declare function initSchema(): {
         minLength?: number | undefined;
     } | undefined) => import("./schema/string.js").StringSchema<T>;
     boolean: () => import("./schema/index.js").Schema<boolean>;
-    array: <S extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S) => import("./schema/index.js").Schema<import("./schema/index.js").SchemaTypeOf<S>[]>;
+    array: <S extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S) => import("./schema/index.js").Schema<import("./schema/index.js").SelectorOfSchema<S>[]>;
     object: <Props extends {
         [key: string]: import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>;
-    }>(schema: Props) => import("./schema/index.js").Schema<{ [key in keyof Props]: import("./schema/index.js").SchemaTypeOf<Props[key]>; }>;
+    }>(schema: Props) => import("./schema/index.js").Schema<{ [key in keyof Props]: import("./schema/index.js").SelectorOfSchema<Props[key]>; }>;
     number: (options?: {
         max?: number | undefined;
         min?: number | undefined;
@@ -51,5 +51,5 @@ export declare function initSchema(): {
     image: (options?: import("./schema/image.js").ImageOptions | undefined) => import("./schema/index.js").Schema<import("./index.js").FileSource<import("./schema/image.js").ImageMetadata>>;
     literal: <T_2 extends string>(value: T_2) => import("./schema/index.js").Schema<T_2>;
     keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject | import("./source/index.js").SourceArray, undefined> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./schema/index.js").Schema<Src extends import("./selector/index.js").GenericSelector<infer S_2 extends import("./source/index.js").Source, undefined> ? S_2 extends readonly any[] ? number : S_2 extends import("./source/index.js").SourceObject ? keyof S_2 : S_2 extends Record<string, any> ? string : never : never>;
-    record: <S_3 extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S_3) => import("./schema/index.js").Schema<Record<string, import("./schema/index.js").SchemaTypeOf<S_3>>>;
+    record: <S_3 extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S_3) => import("./schema/index.js").Schema<Record<string, import("./schema/index.js").SelectorOfSchema<S_3>>>;
 };

package/dist/declarations/src/module.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaTypeOf, SerializedSchema } from "./schema/index.js";
+import { Schema, SelectorOfSchema, SerializedSchema } from "./schema/index.js";
 import { GenericSelector, SelectorOf, SelectorSource } from "./selector/index.js";
 import { Source } from "./source/index.js";
 import { ModuleId, ModulePath, SourcePath } from "./val/index.js";
@@ -9,13 +9,13 @@ export type ValModule<T extends SelectorSource> = SelectorOf<T> & ValModuleBrand
 export type ValModuleBrand = {
     [brand]: "ValModule";
 };
-export type TypeOfValModule<T extends ValModule<SelectorSource>> = T extends GenericSelector<infer S> ? S : never;
+export type InferValModuleType<T extends ValModule<SelectorSource>> = T extends GenericSelector<infer S> ? S : never;
 type ReplaceRawStringWithString<T extends SelectorSource> = SelectorSource extends T ? T : T extends RawString ? string : T extends {
     [key in string]: SelectorSource;
 } ? {
     [key in keyof T]: ReplaceRawStringWithString<T[key]>;
 } : T extends SelectorSource[] ? ReplaceRawStringWithString<T[number]>[] : T;
-export declare function content<T extends Schema<SelectorSource>>(id: string, schema: T, source: ReplaceRawStringWithString<SchemaTypeOf<T>>): ValModule<SchemaTypeOf<T>>;
+export declare function content<T extends Schema<SelectorSource>>(id: string, schema: T, source: ReplaceRawStringWithString<SelectorOfSchema<T>>): ValModule<SelectorOfSchema<T>>;
 export declare function getSource(valModule: ValModule<SelectorSource>): Source;
 export declare function splitModuleIdAndModulePath(path: SourcePath): [moduleId: ModuleId, path: ModulePath];
 export declare function getSourceAtPath(modulePath: ModulePath, valModule: ValModule<SelectorSource> | Source): any;

package/dist/declarations/src/schema/array.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaTypeOf, SerializedSchema } from "./index.js";
+import { Schema, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -7,13 +7,13 @@ export type SerializedArraySchema = {
     item: SerializedSchema;
     opt: boolean;
 };
-export declare class ArraySchema<T extends Schema<SelectorSource>> extends Schema<SchemaTypeOf<T>[]> {
+export declare class ArraySchema<T extends Schema<SelectorSource>> extends Schema<SelectorOfSchema<T>[]> {
     readonly item: T;
     readonly opt: boolean;
     constructor(item: T, opt?: boolean);
-    validate(path: SourcePath, src: SchemaTypeOf<T>[]): ValidationErrors;
-    assert(src: SchemaTypeOf<T>[]): boolean;
-    optional(): Schema<SchemaTypeOf<T>[] | null>;
+    validate(path: SourcePath, src: SelectorOfSchema<T>[]): ValidationErrors;
+    assert(src: SelectorOfSchema<T>[]): boolean;
+    optional(): Schema<SelectorOfSchema<T>[] | null>;
     serialize(): SerializedArraySchema;
 }
-export declare const array: <S extends Schema<SelectorSource>>(schema: S) => Schema<SchemaTypeOf<S>[]>;
+export declare const array: <S extends Schema<SelectorSource>>(schema: S) => Schema<SelectorOfSchema<S>[]>;

package/dist/declarations/src/schema/index.d.ts

@@ -21,4 +21,4 @@ export declare abstract class Schema<Src extends SelectorSource> {
     /** MUTATES! since internal and perf sensitive */
     protected appendValidationError(current: ValidationErrors, path: SourcePath, message: string, value?: unknown): ValidationErrors;
 }
-export type SchemaTypeOf<T extends Schema<SelectorSource>> = T extends Schema<infer Src> ? Src : never;
+export type SelectorOfSchema<T extends Schema<SelectorSource>> = T extends Schema<infer Src> ? Src : never;

package/dist/declarations/src/schema/object.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaTypeOf, SerializedSchema } from "./index.js";
+import { Schema, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -11,7 +11,7 @@ type ObjectSchemaProps = {
     [key: string]: Schema<SelectorSource>;
 };
 type ObjectSchemaSrcOf<Props extends ObjectSchemaProps> = {
-    [key in keyof Props]: SchemaTypeOf<Props[key]>;
+    [key in keyof Props]: SelectorOfSchema<Props[key]>;
 };
 export declare class ObjectSchema<Props extends ObjectSchemaProps> extends Schema<ObjectSchemaSrcOf<Props>> {
     readonly items: Props;
@@ -22,5 +22,5 @@ export declare class ObjectSchema<Props extends ObjectSchemaProps> extends Schem
     optional(): Schema<ObjectSchemaSrcOf<Props> | null>;
     serialize(): SerializedSchema;
 }
-export declare const object: <Props extends ObjectSchemaProps>(schema: Props) => Schema<{ [key in keyof Props]: SchemaTypeOf<Props[key]>; }>;
+export declare const object: <Props extends ObjectSchemaProps>(schema: Props) => Schema<{ [key in keyof Props]: SelectorOfSchema<Props[key]>; }>;
 export {};

package/dist/declarations/src/schema/record.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaTypeOf, SerializedSchema } from "./index.js";
+import { Schema, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -7,13 +7,13 @@ export type SerializedRecordSchema = {
     item: SerializedSchema;
     opt: boolean;
 };
-export declare class RecordSchema<T extends Schema<SelectorSource>> extends Schema<Record<string, SchemaTypeOf<T>>> {
+export declare class RecordSchema<T extends Schema<SelectorSource>> extends Schema<Record<string, SelectorOfSchema<T>>> {
     readonly item: T;
     readonly opt: boolean;
     constructor(item: T, opt?: boolean);
-    validate(path: SourcePath, src: Record<string, SchemaTypeOf<T>>): ValidationErrors;
-    assert(src: Record<string, SchemaTypeOf<T>>): boolean;
-    optional(): Schema<Record<string, SchemaTypeOf<T>> | null>;
+    validate(path: SourcePath, src: Record<string, SelectorOfSchema<T>>): ValidationErrors;
+    assert(src: Record<string, SelectorOfSchema<T>>): boolean;
+    optional(): Schema<Record<string, SelectorOfSchema<T>> | null>;
     serialize(): SerializedRecordSchema;
 }
-export declare const record: <S extends Schema<SelectorSource>>(schema: S) => Schema<Record<string, SchemaTypeOf<S>>>;
+export declare const record: <S extends Schema<SelectorSource>>(schema: S) => Schema<Record<string, SelectorOfSchema<S>>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/core",
-  "version": "0.43.0",
+  "version": "0.43.1",
   "private": false,
   "description": "Val - supercharged hard-coded content",
   "scripts": {