@based/schema 5.0.0-alpha.2 → 5.0.0-alpha.21

package/dist/serialize.js

@@ -0,0 +1,473 @@
+// import * as deflate from 'fflate'
+import { stringFormats } from './types.js';
+import { REVERSE_TYPE_INDEX_MAP, TYPE_INDEX_MAP } from './def/types.js';
+import { readDoubleLE, readUint16, readUint24, readUint32, writeDoubleLE, writeUint16, writeUint24, writeUint32, } from '@saulx/utils';
+const ENCODER = new TextEncoder();
+const UINT8 = 245;
+const FALSE = 246;
+const TRUE = 247;
+const FUNCTION = 248;
+const STRING = 249;
+const ARRAY = 250;
+const BINARY = 251;
+const UINT32 = 252;
+const FLOAT64 = 253;
+const SCHEMA_PROP = 254;
+const OBJECT = 255;
+// Key Address encoding types
+const KEY_ADDRESS_1_BYTE = 0;
+const KEY_ADDRESS_2_BYTES = 1;
+const KEY_ADDRESS_3_BYTES = 2;
+// Key types
+const PROPS = 3;
+const TYPES = 4;
+const READONLY = 5;
+const FORMAT = 6;
+const REQUIRED = 7;
+const REF = 8;
+const PROP = 9;
+const KEY_OPTS = PROP;
+const ensureCapacity = (required) => {
+    if (schemaBuffer.len + required > schemaBuffer.buf.length) {
+        const newBuf = new Uint8Array(Math.max(schemaBuffer.buf.length * 2, schemaBuffer.len + required));
+        newBuf.set(schemaBuffer.buf);
+        schemaBuffer.buf = newBuf;
+    }
+};
+let schemaBuffer;
+const handleSingleValue = (ops, val, obj, prev, fromObject, key, isTypes) => {
+    const type = typeof val;
+    // typed Array - single PROP
+    if (val instanceof Uint8Array) {
+        ensureCapacity(1 + 2 + val.byteLength);
+        schemaBuffer.buf[schemaBuffer.len] = BINARY;
+        schemaBuffer.len += 1;
+        schemaBuffer.buf[schemaBuffer.len] = val.byteLength;
+        schemaBuffer.len += 1;
+        schemaBuffer.buf[schemaBuffer.len] = val.byteLength >>> 8;
+        schemaBuffer.len += 1;
+        schemaBuffer.buf.set(val, schemaBuffer.len);
+        schemaBuffer.len += val.byteLength;
+    }
+    else if (type === 'function') {
+        const str = val.toString();
+        // Pessimistically assume 4 bytes per char for UTF-8 to be safe.
+        ensureCapacity(1 + 2 + str.length * 4);
+        schemaBuffer.buf[schemaBuffer.len] = FUNCTION;
+        schemaBuffer.len += 1;
+        const sizeIndex = schemaBuffer.len;
+        schemaBuffer.len += 2;
+        // encodeInto is much faster as it avoids intermediate allocation.
+        const r = ENCODER.encodeInto(str, schemaBuffer.buf.subarray(schemaBuffer.len));
+        schemaBuffer.len += r.written;
+        schemaBuffer.buf[sizeIndex] = r.written;
+        schemaBuffer.buf[sizeIndex + 1] = r.written >>> 8;
+    }
+    else if (type === 'object') {
+        // fromObject
+        if (val === null) {
+        }
+        else {
+            if (!fromObject && key === 'props' && obj.type === 'object') {
+                walk(ops, val, obj, prev, true, schemaBuffer, false);
+            }
+            else {
+                walk(ops, val, obj, prev, fromObject, schemaBuffer, isTypes);
+            }
+        }
+    }
+    else if (type === 'boolean') {
+        ensureCapacity(1);
+        schemaBuffer.buf[schemaBuffer.len] = val ? TRUE : FALSE;
+        schemaBuffer.len += 1;
+    }
+    else if (type === 'string') {
+        // Pessimistically assume 4 bytes per char for UTF-8 to be safe.
+        ensureCapacity(1 + 2 + val.length * 4);
+        schemaBuffer.buf[schemaBuffer.len] = STRING;
+        schemaBuffer.len += 1;
+        const sizeIndex = schemaBuffer.len;
+        schemaBuffer.len += 2;
+        // encodeInto is much faster as it avoids intermediate allocation.
+        const r = ENCODER.encodeInto(val, schemaBuffer.buf.subarray(schemaBuffer.len));
+        schemaBuffer.len += r.written;
+        schemaBuffer.buf[sizeIndex] = r.written;
+        schemaBuffer.buf[sizeIndex + 1] = r.written >>> 8;
+    }
+    else if (type === 'number') {
+        const isInt = val % 1 === 0;
+        if (val < 256 && val > 0 && isInt) {
+            ensureCapacity(2);
+            schemaBuffer.buf[schemaBuffer.len] = UINT8;
+            schemaBuffer.len += 1;
+            schemaBuffer.buf[schemaBuffer.len] = val;
+            schemaBuffer.len += 1;
+        }
+        else if ((val < 4294967295 || val > 0) && isInt) {
+            ensureCapacity(5);
+            schemaBuffer.buf[schemaBuffer.len] = UINT32;
+            schemaBuffer.len += 1;
+            writeUint32(schemaBuffer.buf, val, schemaBuffer.len);
+            schemaBuffer.len += 4;
+        }
+        else {
+            ensureCapacity(9);
+            schemaBuffer.buf[schemaBuffer.len] = FLOAT64;
+            schemaBuffer.len += 1;
+            writeDoubleLE(schemaBuffer.buf, val, schemaBuffer.len);
+            schemaBuffer.len += 8;
+        }
+    }
+};
+const encodeKey = (key, schemaBuffer) => {
+    let address = schemaBuffer.dictMap[key];
+    // if len == 1 never from address
+    if (!address) {
+        // pessimistically assume 4 bytes per char for UTF-8 to be safe.
+        ensureCapacity(1 + key.length * 4);
+        address = schemaBuffer.len;
+        schemaBuffer.len += 1;
+        const r = ENCODER.encodeInto(key, schemaBuffer.buf.subarray(schemaBuffer.len));
+        schemaBuffer.buf[address] = r.written + KEY_OPTS;
+        schemaBuffer.len += r.written;
+        schemaBuffer.dictMap[key] = address;
+    }
+    else {
+        ensureCapacity(4);
+        if (address > 65025) {
+            schemaBuffer.buf[schemaBuffer.len] = KEY_ADDRESS_3_BYTES;
+            schemaBuffer.len += 1;
+            writeUint24(schemaBuffer.buf, address, schemaBuffer.len);
+            schemaBuffer.len += 3;
+        }
+        else if (address > 255) {
+            schemaBuffer.buf[schemaBuffer.len] = KEY_ADDRESS_2_BYTES;
+            schemaBuffer.len += 1;
+            writeUint16(schemaBuffer.buf, address, schemaBuffer.len);
+            schemaBuffer.len += 2;
+        }
+        else {
+            schemaBuffer.buf[schemaBuffer.len] = KEY_ADDRESS_1_BYTE;
+            schemaBuffer.len += 1;
+            schemaBuffer.buf[schemaBuffer.len] = address;
+            schemaBuffer.len += 1;
+        }
+    }
+};
+// 3 level
+// 0 for queries (min)
+// 1 for modify
+// 2 fulls schema
+const walk = (opts, obj, prev, prev2, fromObject, schemaBuffer, isTypes) => {
+    let start = schemaBuffer.len;
+    const isArray = Array.isArray(obj);
+    const isFromObj = prev2?.type === 'object' || fromObject === false;
+    const isSchemaProp = 'type' in obj && isFromObj;
+    ensureCapacity(1 + 4); // Type byte + size
+    if (isSchemaProp) {
+        schemaBuffer.buf[schemaBuffer.len++] = SCHEMA_PROP;
+        const typeIndex = TYPE_INDEX_MAP[obj.type];
+        schemaBuffer.buf[schemaBuffer.len++] = typeIndex;
+    }
+    else {
+        schemaBuffer.buf[schemaBuffer.len++] = isArray ? ARRAY : OBJECT;
+    }
+    let sizeIndex = schemaBuffer.len;
+    schemaBuffer.len += 2;
+    if (isArray) {
+        const len = obj.length;
+        ensureCapacity(2 * len + 2);
+        writeUint16(schemaBuffer.buf, len, schemaBuffer.len);
+        schemaBuffer.len += 2;
+        for (let j = 0; j < len; j++) {
+            if (len < 256) {
+                schemaBuffer.buf[schemaBuffer.len] = j;
+                schemaBuffer.len += 1;
+            }
+            else {
+                writeUint16(schemaBuffer.buf, j, schemaBuffer.len);
+                schemaBuffer.len += 2;
+            }
+            handleSingleValue(opts, obj[j], obj, prev, fromObject, j);
+        }
+    }
+    else {
+        for (const key in obj) {
+            if (opts.readOnly &&
+                isFromObj &&
+                (key === 'validation' || key === 'default')) {
+                if (key === 'validation' && typeof obj[key] === 'function') {
+                    continue;
+                }
+                else if (key === 'default') {
+                    continue;
+                }
+            }
+            else if (isFromObj &&
+                (opts.stripMetaInformation || opts.readOnly) &&
+                (key === 'title' ||
+                    key === 'description' ||
+                    key === 'format' ||
+                    key === 'display') &&
+                typeof obj[key] === 'string') {
+                continue;
+            }
+            else if (key === 'type' && isSchemaProp) {
+                continue;
+            }
+            else if (key === 'required' && obj[key] === true) {
+                ensureCapacity(1);
+                schemaBuffer.buf[schemaBuffer.len] = REQUIRED;
+                schemaBuffer.len += 1;
+                continue;
+            }
+            // Add this later
+            else if (key == 'ref' && isFromObj && typeof obj.ref === 'string') {
+                ensureCapacity(1);
+                schemaBuffer.buf[schemaBuffer.len] = REF;
+                schemaBuffer.len += 1;
+                encodeKey(obj[key], schemaBuffer);
+                continue;
+            }
+            else if (key === 'prop' && isFromObj && typeof obj.prop === 'string') {
+                ensureCapacity(1);
+                schemaBuffer.buf[schemaBuffer.len] = PROP;
+                schemaBuffer.len += 1;
+                encodeKey(obj[key], schemaBuffer);
+                continue;
+            }
+            else if (key === 'readOnly' && obj[key] === true) {
+                ensureCapacity(1);
+                schemaBuffer.buf[schemaBuffer.len] = READONLY;
+                schemaBuffer.len += 1;
+                continue;
+            }
+            else if (key === 'format' && isFromObj) {
+                ensureCapacity(2);
+                schemaBuffer.buf[schemaBuffer.len] = FORMAT;
+                schemaBuffer.len += 1;
+                schemaBuffer.buf[schemaBuffer.len] = stringFormats.indexOf(obj.format);
+                schemaBuffer.len += 1;
+                continue;
+            }
+            else {
+                let isTypes = false;
+                if (key === 'types') {
+                    //  undefined undefined false
+                    if (!prev && !prev2 && !fromObject) {
+                        isTypes = true;
+                    }
+                    ensureCapacity(1);
+                    schemaBuffer.buf[schemaBuffer.len] = TYPES;
+                    schemaBuffer.len += 1;
+                }
+                else if (key === 'props') {
+                    ensureCapacity(1);
+                    schemaBuffer.buf[schemaBuffer.len] = PROPS;
+                    schemaBuffer.len += 1;
+                }
+                else {
+                    encodeKey(key, schemaBuffer);
+                }
+                handleSingleValue(opts, obj[key], obj, prev, fromObject, key, isTypes);
+            }
+        }
+    }
+    let size = schemaBuffer.len - start;
+    schemaBuffer.buf[sizeIndex] = size;
+    schemaBuffer.buf[sizeIndex + 1] = size >>> 8;
+};
+export const serialize = (schema, opts = {}) => {
+    if (!schemaBuffer) {
+        schemaBuffer = {
+            buf: new Uint8Array(10e3), // 10kb default
+            len: 0,
+            dictMap: {},
+        };
+    }
+    schemaBuffer.len = 0;
+    schemaBuffer.dictMap = {};
+    // defalte not supported in unpacking yet
+    const isDeflate = 0; // opts.deflate ? 1 : 0
+    walk(opts, schema, undefined, undefined, false, schemaBuffer, false);
+    const packed = new Uint8Array(schemaBuffer.buf.subarray(0, schemaBuffer.len));
+    // if (isDeflate) {
+    //   // add extra byte! see if nessecary
+    //   return deflate.deflateSync(packed)
+    // } else {
+    return packed;
+    // }
+};
+const decoder = new TextDecoder();
+export const deSerializeKey = (buf, keySize, i) => {
+    let size = 0;
+    let value;
+    if (keySize === KEY_ADDRESS_3_BYTES) {
+        const dictAddress = readUint24(buf, i);
+        size += 3;
+        const actualKeySize = buf[dictAddress] - KEY_OPTS;
+        value = decoder.decode(buf.subarray(dictAddress + 1, actualKeySize + dictAddress + 1));
+    }
+    else if (keySize === KEY_ADDRESS_2_BYTES) {
+        const dictAddress = readUint16(buf, i);
+        size += 2;
+        const actualKeySize = buf[dictAddress] - KEY_OPTS;
+        value = decoder.decode(buf.subarray(dictAddress + 1, actualKeySize + dictAddress + 1));
+    }
+    else if (keySize === KEY_ADDRESS_1_BYTE) {
+        const dictAddress = buf[i];
+        size += 1;
+        const actualKeySize = buf[dictAddress] - KEY_OPTS;
+        value = decoder.decode(buf.subarray(dictAddress + 1, actualKeySize + dictAddress + 1));
+    }
+    else {
+        const actualKeySize = keySize - KEY_OPTS;
+        value = decoder.decode(buf.subarray(i, actualKeySize + i));
+        size += actualKeySize;
+    }
+    return { size, value };
+};
+export const deSerializeInner = (buf, obj, start, fromArray) => {
+    let i = start;
+    const isSchemaProp = buf[i] === SCHEMA_PROP;
+    i += 1;
+    if (isSchemaProp) {
+        const type = buf[i];
+        const parsedType = REVERSE_TYPE_INDEX_MAP[type];
+        obj.type = parsedType;
+        i += 1;
+    }
+    const size = readUint16(buf, i);
+    i += 2;
+    const end = size + start;
+    if (fromArray) {
+        i += 2;
+    }
+    while (i < end) {
+        let key;
+        if (fromArray) {
+            if (obj.length < 256) {
+                key = buf[i];
+                i += 1;
+            }
+            else {
+                key = readUint16(buf, i);
+                i += 2;
+            }
+        }
+        else {
+            let keySize = buf[i];
+            i += 1;
+            // format!
+            if (keySize === REQUIRED) {
+                obj.required = true;
+                continue;
+            }
+            else if (keySize === FORMAT) {
+                obj.format = stringFormats[buf[i]];
+                i += 1;
+                continue;
+            }
+            else if (keySize === READONLY) {
+                obj.readOnly = true;
+                continue;
+            }
+            else if (keySize === TYPES) {
+                key = 'types';
+            }
+            else if (keySize === PROPS) {
+                key = 'props';
+            }
+            else if (keySize === REF) {
+                const valueKeySize = buf[i];
+                i += 1;
+                const { size, value } = deSerializeKey(buf, valueKeySize, i);
+                i += size;
+                obj.ref = value;
+                continue;
+            }
+            else if (keySize === PROP) {
+                const valueKeySize = buf[i];
+                i += 1;
+                const { size, value } = deSerializeKey(buf, valueKeySize, i);
+                i += size;
+                obj.prop = value;
+                continue;
+            }
+            else {
+                const { size, value } = deSerializeKey(buf, keySize, i);
+                i += size;
+                key = value;
+            }
+        }
+        if (buf[i] === UINT8) {
+            i += 1;
+            obj[key] = buf[i];
+            i += 1;
+        }
+        else if (buf[i] === FALSE) {
+            i += 1;
+            obj[key] = false;
+        }
+        else if (buf[i] === TRUE) {
+            i += 1;
+            obj[key] = true;
+        }
+        else if (buf[i] === FUNCTION) {
+            i += 1;
+            const size = readUint16(buf, i);
+            i += 2;
+            const fn = `return (${decoder.decode(buf.subarray(i, i + size))})(payload, prop)`;
+            obj[key] = new Function('payload', 'prop', fn);
+            i += size;
+        }
+        else if (buf[i] === STRING) {
+            i += 1;
+            const size = readUint16(buf, i);
+            i += 2;
+            obj[key] = decoder.decode(buf.subarray(i, i + size));
+            i += size;
+        }
+        else if (buf[i] === BINARY) {
+            i += 1;
+            const size = readUint16(buf, i);
+            i += 2;
+            obj[key] = buf.subarray(i, size + i);
+            i += size;
+        }
+        else if (buf[i] === UINT32) {
+            obj[key] = readUint32(buf, i + 1);
+            i += 5;
+        }
+        else if (buf[i] === FLOAT64) {
+            obj[key] = readDoubleLE(buf, i + 1);
+            i += 9;
+        }
+        else if (buf[i] === OBJECT || buf[i] === SCHEMA_PROP) {
+            const nest = (obj[key] = {});
+            const fieldSize = deSerializeInner(buf, nest, i, false);
+            i += fieldSize;
+        }
+        else if (buf[i] === ARRAY) {
+            const len = readUint16(buf, i + 3);
+            const nest = (obj[key] = new Array(len));
+            const fieldSize = deSerializeInner(buf, nest, i, true);
+            i += fieldSize;
+        }
+        else {
+            console.warn('Invalid value type', buf[i], 'skip');
+            // Invalid value type
+            i += 1;
+            const size = buf[i] | ((buf[i + 1] << 8) >>> 0);
+            i += size;
+        }
+    }
+    return i - start;
+};
+export const deSerialize = (buf) => {
+    // if first byte is deflate
+    const schema = {};
+    deSerializeInner(buf, schema, 0, false);
+    return schema;
+};
+//# sourceMappingURL=serialize.js.map

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;
@@ -24,6 +26,7 @@ type Prop<V extends PropValues> = {
     role?: Role;
     readOnly?: boolean;
     examples?: string[];
+    validation?: Validation;
 } & V;
 type EnumItem = string | number | boolean;
 type NeverInItems = {
@@ -31,15 +34,19 @@ type NeverInItems = {
 };
 export type SchemaReferences = Prop<{
     type?: 'references';
+    default?: number[];
     items: SchemaReference & NeverInItems;
 }>;
 export type SchemaReferencesOneWay = Prop<{
     type?: 'references';
+    default?: number[];
     items: SchemaReferenceOneWay & NeverInItems;
 }>;
 export type SchemaText = Prop<{
     type: 'text';
     default?: Record<string, string>;
+    format?: StringFormat;
+    compression?: 'none' | 'deflate';
 }>;
 type NumberType = 'number' | 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32';
 export type SchemaNumber = Prop<{
@@ -65,7 +72,7 @@ export type SchemaString = Prop<{
 }>;
 export type SchemaBinary = Prop<{
     type: 'binary';
-    default?: ArrayBuffer;
+    default?: Uint8Array;
     maxBytes?: number;
     mime?: Mime;
     format?: StringFormat;
@@ -80,7 +87,6 @@ export type SchemaBoolean = Prop<{
 }>;
 export type SchemaCardinality = Prop<{
     type: 'cardinality';
-    default?: string;
     maxBytes?: number;
     mime?: Mime;
     format?: NumberDisplay;
@@ -90,21 +96,29 @@ export type SchemaVector = Prop<{
     default?: Float32Array;
     size: number;
 }>;
+export type SchemaColvec = Prop<{
+    type: 'colvec';
+    default?: Float32Array;
+    size: number;
+}>;
 export type SchemaTimestamp = Prop<{
     type: 'timestamp';
-    default?: number | Date;
+    default?: number | Date | string;
     on?: 'create' | 'update';
     display?: DateDisplay;
+    min?: number | string;
+    max?: number | string;
+    step?: number | 'any' | string;
 }>;
 export type SchemaReferenceOneWay = Prop<{
     type?: 'reference';
-    default?: string;
+    default?: number;
     ref: string;
     mime?: Mime;
 }>;
 export type SchemaReference = Prop<{
     type?: 'reference';
-    default?: string;
+    default?: number;
     ref: string;
     prop: string;
     dependent?: boolean;
@@ -126,7 +140,7 @@ export type SchemaReferencesWithQuery = SchemaReferencesOneWay & {
 };
 export type SchemaEnum = Prop<{
     type?: 'enum';
-    default?: EnumItem;
+    default?: EnumItem | undefined;
     enum: EnumItem[];
 }>;
 export type SchemaAlias = Omit<SchemaString, 'type'> & {
@@ -141,7 +155,7 @@ export type SchemaSet<ItemsType extends SetItems = SetItems> = Prop<{
     } ? ItemsType['default'][] : undefined;
     items: ItemsType & NeverInItems;
 }>;
-type NonRefSchemaProps<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaJson | SchemaBinary | SchemaCardinality | SchemaVector | (isStrict extends true ? SchemaSet<SetItems<true>> : SchemaPropShorthand | SchemaSet);
+type NonRefSchemaProps<isStrict = false> = SchemaTimestamp | SchemaBoolean | SchemaNumber | SchemaString | SchemaAlias | SchemaText | SchemaEnum | SchemaJson | SchemaBinary | SchemaCardinality | SchemaVector | SchemaColvec | (isStrict extends true ? SchemaSet<SetItems<true>> : SchemaPropShorthand | SchemaSet);
 export type SchemaProp<isStrict = false> = SchemaReferencesWithQuery | SchemaReferenceWithQuery | NonRefSchemaProps<isStrict> | SchemaReferences | SchemaReference | SchemaObject | SchemaBinary;
 export type SchemaPropOneWay<isStrict = false> = SchemaReferencesOneWay | SchemaReferenceOneWay | SchemaObjectOneWay | NonRefSchemaProps<isStrict>;
 export type SchemaAnyProp = SchemaPropOneWay | SchemaProp;
@@ -156,6 +170,9 @@ type GenericSchemaType<isStrict = false> = {
         delete?: SchemaHook;
     };
     id?: number;
+    blockCapacity?: number;
+    insertOnly?: boolean;
+    partial?: boolean;
     props: SchemaProps<isStrict>;
 };
 export type StrictSchemaType = GenericSchemaType<true>;
@@ -176,9 +193,9 @@ type GenericSchema<isStrict = false> = {
 };
 export type StrictSchema = GenericSchema<true>;
 export type Schema = GenericSchema<false> | StrictSchema;
-export type SchemaLocales = Record<LangName, {
+export type SchemaLocales = Record<LangName, true | {
     required?: boolean;
-    fallback?: LangName[];
+    fallback?: LangName;
 }>;
 export type SchemaPropTypeMap = {
     references: SchemaReferences;
@@ -195,8 +212,11 @@ export type SchemaPropTypeMap = {
     binary: SchemaBinary;
     cardinality: SchemaCardinality;
     vector: SchemaVector;
+    colvec: SchemaColvec;
 } & Record<NumberType, SchemaNumber>;
 export type SchemaPropTypes = keyof SchemaPropTypeMap;
 export declare const isPropType: <T extends SchemaPropTypes>(type: T, prop: SchemaProp) => prop is SchemaPropTypeMap[T];
+export declare const MAX_ID = 4294967295;
+export declare const MIN_ID = 1;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -95,4 +95,6 @@ export const stringFormats = [
 export const isPropType = (type, prop) => {
     return getPropType(prop) === type;
 };
+export const MAX_ID = 4294967295;
+export const MIN_ID = 1;
 //# sourceMappingURL=types.js.map

package/dist/validation/validation.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation/validation.js

@@ -0,0 +1,6 @@
+export {};
+// use typeIndex here
+// end export them per type
+// can also add validate on the prop def
+// this way we can actually write custom ones
+//# sourceMappingURL=validation.js.map

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.2",
+  "version": "5.0.0-alpha.21",
   "license": "MIT",
-  "main": "dist/index.js",
   "files": [
     "dist",
     "README.md",
     "package.json",
     "!dist/**/*.map"
   ],
+  "main": "./dist/index.js",
+  "exports": {
+    "./def": "./dist/def/index.js",
+    ".": "./dist/index.js"
+  },
   "scripts": {
     "build": "tsc",
     "watch": "tsc --watch",
-    "test": "tsc && tsc test/*.ts --noEmit && tsx --test test/*.ts",
-    "test1": "tsc && tsc $npm_config --noEmit && tsx --test $npm_config"
+    "test": "tsc && tsc $npm_config --noEmit && tsx --test $npm_config"
   },
   "prettier": "@saulx/prettier-config",
   "sideEffects": false,
@@ -26,6 +29,7 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
+    "@saulx/utils": "^6.7.0",
     "picocolors": "^1.1.0"
   }
 }