@based/schema 5.0.0-alpha.7 → 5.0.0-alpha.9

package/dist/def/addEdges.js

@@ -1,6 +1,7 @@
 import { getPropType } from '../index.js';
 import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, ENUM, } from './types.js';
 import { getPropLen, isSeparate } from './utils.js';
+import { defaultValidation, VALIDATION_MAP } from './validation.js';
 export const addEdges = (prop, refProp) => {
     for (const key in refProp) {
         if (key[0] === '$') {
@@ -18,12 +19,15 @@ export const addEdges = (prop, refProp) => {
             if (separate) {
                 prop.edgesSeperateCnt++;
             }
+            const typeIndex = TYPE_INDEX_MAP[edgeType];
+            // add default
             const edge = {
                 __isPropDef: true,
                 __isEdge: true,
                 prop: separate ? prop.edgesSeperateCnt : 0,
+                validation: edgeProp.validate ?? VALIDATION_MAP[typeIndex] ?? defaultValidation,
                 name: key,
-                typeIndex: TYPE_INDEX_MAP[edgeType],
+                typeIndex,
                 len,
                 separate,
                 path: [...prop.path, key],

package/dist/def/createEmptyDef.d.ts

@@ -8,6 +8,7 @@ export declare const createEmptyDef: (typeName: string, type: StrictSchemaType |
     reverseProps: {};
     idUint8: Uint8Array;
     id: number;
+    mainEmpty: Uint8Array;
     mainLen: number;
     separate: any[];
     tree: {};

package/dist/def/createEmptyDef.js

@@ -8,7 +8,9 @@ export const createEmptyDef = (typeName, type, locales) => {
         props: {},
         reverseProps: {},
         idUint8: new Uint8Array([0, 0]),
+        // empty main buffer
         id: 0,
+        mainEmpty: new Uint8Array(0),
         mainLen: 0,
         separate: [],
         tree: {},

package/dist/def/defaultMap.d.ts

@@ -0,0 +1,3 @@
+import { TypeIndex } from './types.js';
+export declare const DEFAULT_MAP: Record<TypeIndex, any>;
+//# sourceMappingURL=defaultMap.d.ts.map

package/dist/def/defaultMap.js

@@ -0,0 +1,27 @@
+import { TYPE_INDEX_MAP } from './types.js';
+// TODO update defaults
+export const DEFAULT_MAP = {
+    [TYPE_INDEX_MAP.alias]: '',
+    [TYPE_INDEX_MAP.binary]: undefined,
+    [TYPE_INDEX_MAP.boolean]: false,
+    [TYPE_INDEX_MAP.cardinality]: 0,
+    [TYPE_INDEX_MAP.number]: 0,
+    [TYPE_INDEX_MAP.timestamp]: 0,
+    [TYPE_INDEX_MAP.enum]: 0,
+    [TYPE_INDEX_MAP.id]: 0,
+    [TYPE_INDEX_MAP.int16]: 0,
+    [TYPE_INDEX_MAP.int32]: 0,
+    [TYPE_INDEX_MAP.int8]: 0,
+    [TYPE_INDEX_MAP.uint8]: 0,
+    [TYPE_INDEX_MAP.uint16]: 0,
+    [TYPE_INDEX_MAP.uint32]: 0,
+    [TYPE_INDEX_MAP.json]: undefined,
+    [TYPE_INDEX_MAP.microbuffer]: undefined,
+    [TYPE_INDEX_MAP.reference]: undefined,
+    [TYPE_INDEX_MAP.references]: [],
+    [TYPE_INDEX_MAP.string]: '',
+    [TYPE_INDEX_MAP.aliases]: [],
+    [TYPE_INDEX_MAP.text]: '',
+    [TYPE_INDEX_MAP.vector]: undefined, // maybe not can set a vec with 0
+};
+//# sourceMappingURL=defaultMap.js.map

package/dist/def/fillEmptyMain.d.ts

@@ -0,0 +1,5 @@
+import { PropDef } from './types.js';
+export declare const ENCODER: TextEncoder;
+export declare const fillEmptyMain: (vals: PropDef[], mainLen: number) => Uint8Array;
+export declare const isZeroes: (buf: Uint8Array) => boolean;
+//# sourceMappingURL=fillEmptyMain.d.ts.map

package/dist/def/fillEmptyMain.js

@@ -0,0 +1,53 @@
+import { BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, } from './types.js';
+// Lets add validation of values in here - need to validate DEFAULT!
+export const ENCODER = new TextEncoder();
+export const fillEmptyMain = (vals, mainLen) => {
+    const mainEmpty = new Uint8Array(mainLen);
+    for (const f of vals) {
+        if (f.separate) {
+            continue;
+        }
+        const t = f.typeIndex;
+        const s = f.start;
+        let val = f.default;
+        if (t === BOOLEAN || t === INT8 || t === UINT8 || t === ENUM) {
+            mainEmpty[s] = val === true ? 1 : 0;
+        }
+        else if (t === UINT32 || t === INT32) {
+            mainEmpty[s] = val;
+            mainEmpty[s + 1] = val >>>= 8;
+            mainEmpty[s + 2] = val >>>= 8;
+            mainEmpty[s + 3] = val >>>= 8;
+        }
+        else if (t === UINT16 || t === INT16) {
+            mainEmpty[s] = val;
+            mainEmpty[s + 1] = val >>>= 8;
+        }
+        else if (t === NUMBER || t === TIMESTAMP) {
+            const view = new DataView(mainEmpty.buffer, s, 8);
+            view.setFloat64(0, val, true);
+        }
+        else if (t === STRING) {
+            val = ENCODER.encode(val);
+            mainEmpty[s] = val.byteLength;
+            mainEmpty.set(val, s + 1);
+        }
+        else if (t === BINARY) {
+            if (val !== undefined) {
+                mainEmpty.set(val, s);
+            }
+        }
+    }
+    return mainEmpty;
+};
+export const isZeroes = (buf) => {
+    let i = 0;
+    while (i < buf.byteLength) {
+        if (buf[i] !== 0) {
+            return false;
+        }
+        i++;
+    }
+    return true;
+};
+//# sourceMappingURL=fillEmptyMain.js.map

package/dist/def/index.d.ts

@@ -4,4 +4,6 @@ export * from './utils.js';
 export * from './selvaBuffer.js';
 export * from './readFromPacked.js';
 export * from './createEmptyDef.js';
+export * from './defaultMap.js';
+export * from './validation.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/def/index.js

@@ -5,4 +5,6 @@ export * from './utils.js';
 export * from './selvaBuffer.js';
 export * from './readFromPacked.js';
 export * from './createEmptyDef.js';
+export * from './defaultMap.js';
+export * from './validation.js';
 //# sourceMappingURL=index.js.map

package/dist/def/readFromPacked.js

@@ -1,4 +1,6 @@
 import { REVERSE_SIZE_MAP } from './types.js';
+import { DEFAULT_MAP } from './defaultMap.js';
+import { VALIDATION_MAP } from './validation.js';
 export const readFromPacked = (packed) => {
     const size = (packed[0] | (packed[1] << 8)) >>> 0;
     const props = [];
@@ -49,7 +51,6 @@ export const readFromPacked = (packed) => {
     // Text not supported yet
     // Ref not supported yet
     //   compression: 1 (0)
-    // YET
     const result = {
         cnt: 0,
         checksum: 0,
@@ -86,6 +87,8 @@ export const readFromPacked = (packed) => {
             bufferTmp: new Uint8Array([]),
             props: [],
         },
+        mainEmpty: new Uint8Array([]),
+        mainEmptyAllZeroes: true,
         // need this...
         locales: {},
         localeSize: 0,
@@ -97,7 +100,9 @@ export const readFromPacked = (packed) => {
             prop: p.prop,
             separate: false,
             __isPropDef: true,
+            validation: VALIDATION_MAP[p.typeIndex],
             start: s,
+            default: DEFAULT_MAP[p.typeIndex], // tmp
             typeIndex: p.typeIndex,
             path: p.path.split('.'),
             len,
@@ -111,8 +116,10 @@ export const readFromPacked = (packed) => {
             prop: p.prop,
             separate: true,
             __isPropDef: true,
+            validation: VALIDATION_MAP[p.typeIndex],
             start: 0,
             typeIndex: p.typeIndex,
+            default: DEFAULT_MAP[p.typeIndex], // tmp
             path: p.path.split('.'),
             len: 0,
             compression: 1,

package/dist/def/typeDef.js

@@ -1,6 +1,7 @@
 import { isPropType, getPropType, } from '../index.js';
 import { setByPath } from '@saulx/utils';
 import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, } from './types.js';
+import { DEFAULT_MAP } from './defaultMap.js';
 import { makePacked } from './makePacked.js';
 import { makeSeparateTextSort } from './makeSeparateTextSort.js';
 import { makeSeparateSort } from './makeSeparateSort.js';
@@ -9,6 +10,8 @@ import { isSeparate } from './utils.js';
 import { addEdges } from './addEdges.js';
 import { createEmptyDef } from './createEmptyDef.js';
 import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
+import { fillEmptyMain, isZeroes } from './fillEmptyMain.js';
+import { defaultValidation, VALIDATION_MAP } from './validation.js';
 export const DEFAULT_BLOCK_CAPACITY = 100_000;
 export const updateTypeDefs = (schema, schemaTypesParsed, schemaTypesParsedById) => {
     for (const field in schemaTypesParsed) {
@@ -57,6 +60,7 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
     let separateSortProps = 0;
     let separateSortText = 0;
     for (const key in target) {
+        // Create prop def
         const schemaProp = target[key];
         const propPath = [...path, key];
         const propType = getPropType(schemaProp);
@@ -82,15 +86,24 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 separateSortText++;
             }
             const isseparate = isSeparate(schemaProp, len);
+            const typeIndex = TYPE_INDEX_MAP[propType];
             const prop = {
-                typeIndex: TYPE_INDEX_MAP[propType],
+                typeIndex,
                 __isPropDef: true,
                 separate: isseparate,
                 path: propPath,
                 start: 0,
+                validation: schemaProp.validate ?? VALIDATION_MAP[typeIndex] ?? defaultValidation,
                 len,
+                default: schemaProp.default ?? DEFAULT_MAP[typeIndex],
                 prop: isseparate ? ++result.cnt : 0,
             };
+            if (schemaProp.max) {
+                prop.max = schemaProp.max;
+            }
+            if (schemaProp.min) {
+                prop.min = schemaProp.min;
+            }
             if (isPropType('enum', schemaProp)) {
                 prop.enum = Array.isArray(schemaProp) ? schemaProp : schemaProp.enum;
                 prop.reverseEnum = {};
@@ -138,6 +151,7 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
         }
     }
     if (top) {
+        // Put top level together
         const vals = Object.values(result.props);
         vals.sort((a, b) => {
             if (b.separate &&
@@ -168,6 +182,8 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 setByPath(result.tree, f.path, f);
             }
         }
+        result.mainEmpty = fillEmptyMain(vals, result.mainLen);
+        result.mainEmptyAllZeroes = isZeroes(result.mainEmpty);
         makePacked(result, typeName, vals, len);
         if (separateSortText > 0) {
             makeSeparateTextSort(result);

package/dist/def/types.d.ts

@@ -1,8 +1,7 @@
 import type { LangCode, SchemaLocales } from '../index.js';
+import { Validation } from './validation.js';
 export declare const NULL = 0;
 export declare const TIMESTAMP = 1;
-export declare const CREATED = 2;
-export declare const UPDATED = 3;
 export declare const NUMBER = 4;
 export declare const CARDINALITY = 5;
 export declare const INT8 = 20;
@@ -34,8 +33,6 @@ export declare const TYPE_INDEX_MAP: {
     reference: number;
     timestamp: number;
     boolean: number;
-    created: number;
-    updated: number;
     number: number;
     string: number;
     text: number;
@@ -69,6 +66,8 @@ export type PropDef = {
     inversePropNumber?: number;
     enum?: any[];
     dependent?: boolean;
+    validation: Validation;
+    default: any;
     edgeMainLen?: 0;
     reverseEnum?: {
         [key: string]: number;
@@ -83,7 +82,10 @@ export type PropDef = {
     reverseMainEdges?: {
         [start: string]: PropDefEdge;
     };
+    edgeMainEmpty?: Uint8Array;
     __isEdge?: boolean;
+    max?: number;
+    min?: number;
 };
 export type PropDefEdge = Partial<PropDef> & {
     __isPropDef: true;
@@ -133,6 +135,8 @@ export type SchemaTypeDef = {
     main: {
         [start: string]: PropDef;
     };
+    mainEmpty: Uint8Array;
+    mainEmptyAllZeroes: boolean;
     tree: SchemaPropTree;
     hasSeperateSort: boolean;
     seperateSort: SchemaSortUndefinedHandler;
@@ -148,7 +152,7 @@ export type SchemaTypeDef = {
     localeSize: number;
 };
 export declare const SIZE_MAP: Record<InternalSchemaProp, number>;
-export declare let REVERSE_SIZE_MAP: Record<TypeIndex, number>;
+export declare const REVERSE_SIZE_MAP: Record<TypeIndex, number>;
 export declare const REVERSE_TYPE_INDEX_MAP: Record<TypeIndex, InternalSchemaProp>;
 export declare const ID_FIELD_DEF: PropDef;
 export declare const EMPTY_MICRO_BUFFER: PropDef;

package/dist/def/types.js

@@ -1,8 +1,6 @@
 // WARN: The following type codes are used in js and zig but selva has its own typing.
 export const NULL = 0;
 export const TIMESTAMP = 1;
-export const CREATED = 2;
-export const UPDATED = 3;
 export const NUMBER = 4;
 export const CARDINALITY = 5;
 export const INT8 = 20;
@@ -34,8 +32,6 @@ export const TYPE_INDEX_MAP = {
     reference: REFERENCE,
     timestamp: TIMESTAMP,
     boolean: BOOLEAN,
-    created: CREATED,
-    updated: UPDATED,
     number: NUMBER,
     string: STRING,
     text: TEXT,
@@ -54,8 +50,6 @@ export const TYPE_INDEX_MAP = {
 };
 export const SIZE_MAP = {
     timestamp: 8, // 64bit
-    created: 8,
-    updated: 8,
     // double-precision 64-bit binary format IEEE 754 value
     number: 8, // 64bit
     int8: 1,
@@ -83,9 +77,7 @@ const reverseMap = {};
 for (const k in TYPE_INDEX_MAP) {
     reverseMap[TYPE_INDEX_MAP[k]] = k;
 }
-export let REVERSE_SIZE_MAP;
-// @ts-ignore
-REVERSE_SIZE_MAP = {};
+export const REVERSE_SIZE_MAP = {};
 for (const k in SIZE_MAP) {
     REVERSE_SIZE_MAP[TYPE_INDEX_MAP[k]] = SIZE_MAP[k];
 }
@@ -96,7 +88,9 @@ export const ID_FIELD_DEF = {
     path: ['id'],
     start: 0,
     prop: 255,
+    default: 0,
     len: 4,
+    validation: () => true,
     __isPropDef: true,
 };
 export const EMPTY_MICRO_BUFFER = {
@@ -104,8 +98,10 @@ export const EMPTY_MICRO_BUFFER = {
     separate: true,
     path: [''],
     start: 0,
+    default: undefined,
     prop: 0,
     len: 1,
+    validation: () => true,
     __isPropDef: true,
 };
 export const getPropTypeName = (propType) => {

package/dist/def/validation.d.ts

@@ -0,0 +1,5 @@
+import { TypeIndex, PropDef, PropDefEdge } from './types.js';
+export type Validation = (payload: any, prop: PropDef | PropDefEdge) => boolean;
+export declare const VALIDATION_MAP: Record<TypeIndex, Validation>;
+export declare const defaultValidation: () => boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/def/validation.js

@@ -0,0 +1,213 @@
+import { TYPE_INDEX_MAP } from './types.js';
+export const VALIDATION_MAP = {
+    [TYPE_INDEX_MAP.alias]: (value) => {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.binary]: (value) => {
+        if (value instanceof Uint8Array) {
+            return true;
+        }
+        return false;
+    },
+    [TYPE_INDEX_MAP.boolean]: (value) => {
+        if (typeof value !== 'boolean') {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.cardinality]: (val) => {
+        return (typeof val === 'string' ||
+            (val instanceof Uint8Array && val.byteLength === 8));
+    },
+    [TYPE_INDEX_MAP.timestamp]: (value, t) => {
+        if (typeof value === 'string') {
+            return true;
+        }
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int16]: (value, t) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        if (value > 32767 || value < -32768) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int32]: (value, t) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        if (value > 2147483647 || value < -2147483648) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int8]: (value, t) => {
+        // use % for steps size
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        if (value > 127 || value < -128) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint8]: (value, t) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        if (value > 255 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint16]: (value, t) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        if (value > 65535 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint32]: (value, t) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        if (value > 4294967295 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.number]: (value, t) => {
+        if (typeof value !== 'number') {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.enum]: (value, prop) => {
+        if (value === null) {
+            return true;
+        }
+        const arr = prop.enum;
+        for (let i = 0; i < arr.length; i++) {
+            if (value === arr[i]) {
+                return true;
+            }
+        }
+        return false;
+    },
+    [TYPE_INDEX_MAP.id]: (value) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.json]: (value) => {
+        return true;
+    },
+    [TYPE_INDEX_MAP.microbuffer]: (value) => {
+        if (!(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.reference]: (value) => {
+        // if (typeof value !== 'number' && value != null) {
+        //   return false
+        // }
+        return true;
+    },
+    [TYPE_INDEX_MAP.references]: (v) => {
+        if (typeof v !== 'number') {
+            return false;
+        }
+        if (v === 0) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.string]: (value, t) => {
+        // add max etc all here - make a ref to the original SCHEMA
+        if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.aliases]: (value) => {
+        if (!Array.isArray(value)) {
+            return false;
+        }
+        const len = value.length;
+        for (let i = 0; i < len; i++) {
+            if (typeof value[i] !== 'string') {
+                return false;
+            }
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.vector]: (value) => {
+        // Array should be supported
+        if (!(value instanceof Float32Array)) {
+            return false;
+        }
+        return true;
+    },
+};
+export const defaultValidation = () => true;
+//# sourceMappingURL=validation.js.map

package/dist/parse/index.d.ts

@@ -12,7 +12,7 @@ export declare class SchemaParser {
     parseTypes(): void;
     parseProps(props: any, schemaType?: SchemaType): void;
     parseLocales(): void;
-    parse(): void;
+    parse(): StrictSchema;
 }
 export declare const print: (schema: Schema, path: string[]) => string;
 export declare const parse: (schema: Schema) => {

package/dist/parse/index.js

@@ -3,10 +3,11 @@ import { getPropType } from './utils.js';
 import propParsers from './props.js';
 import pc from 'picocolors';
 import { expectBoolean, expectObject } from './assert.js';
+import { deepCopy } from '@saulx/utils';
 export { getPropType };
 export class SchemaParser {
     constructor(schema) {
-        this.schema = schema;
+        this.schema = deepCopy(schema);
     }
     isItems;
     inQuery;
@@ -97,6 +98,7 @@ export class SchemaParser {
                 throw Error(UNKNOWN_PROP);
             }
         }
+        return this.schema;
     }
 }
 export const print = (schema, path) => {
@@ -120,9 +122,7 @@ export const print = (schema, path) => {
 export const parse = (schema) => {
     const parser = new SchemaParser(schema);
     try {
-        parser.parse();
-        // @ts-ignore
-        return { schema };
+        return { schema: parser.parse() };
     }
     catch (e) {
         const cause = parser.path.slice(0, Math.min(4, parser.lvl) + 1);

package/dist/parse/props.js

@@ -270,6 +270,7 @@ p.text = propParser({
         throw Error(TEXT_REQUIRES_LOCALES);
     },
 }, {
+    format: binaryOpts.format,
     default(val, prop) {
         console.warn('MAKE DEFAULT VALUE FOR TEXT');
     },

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import { LangName } from './lang.js';
+import { Validation } from './def/validation.js';
 type Role = 'title' | 'source' | 'media' | string;
 export declare const numberDisplays: readonly ["short", "human", "ratio", "bytes", "euro", "dollar", "pound", "meter"];
 export declare const dateDisplays: readonly ["date", "date-time", "date-time-text", "date-time-human", "time", "time-precise"];
@@ -14,6 +15,7 @@ type QueryFn = Function;
 type PropValues = {
     type?: string;
     default?: any;
+    validation?: Validation;
 };
 type Prop<V extends PropValues> = {
     required?: boolean;
@@ -40,6 +42,7 @@ export type SchemaReferencesOneWay = Prop<{
 export type SchemaText = Prop<{
     type: 'text';
     default?: Record<string, string>;
+    format?: StringFormat;
 }>;
 type NumberType = 'number' | 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32';
 export type SchemaNumber = Prop<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.7",
+  "version": "5.0.0-alpha.9",
   "license": "MIT",
   "files": [
     "dist",
@@ -8,6 +8,7 @@
     "package.json",
     "!dist/**/*.map"
   ],
+  "main": "./dist/index.js",
   "exports": {
     "./def": "./dist/def/index.js",
     ".": "./dist/index.js"
@@ -28,7 +29,7 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@saulx/utils": "^5.0.0",
+    "@saulx/utils": "^6.1.1",
     "picocolors": "^1.1.0"
   }
 }