@based/schema 5.0.0-alpha.1 → 5.0.0-alpha.11

package/dist/def/selvaBuffer.js

@@ -0,0 +1,115 @@
+import { ALIAS, ALIASES, BINARY, EMPTY_MICRO_BUFFER, CARDINALITY, MICRO_BUFFER, REFERENCE, REFERENCES, STRING, TEXT, VECTOR, WEAK_REFERENCE, WEAK_REFERENCES, JSON, } from './types.js';
+const selvaTypeMap = new Uint8Array(32); // 1.2x faster than JS array
+selvaTypeMap[MICRO_BUFFER] = 1;
+selvaTypeMap[VECTOR] = 1;
+selvaTypeMap[BINARY] = 2;
+selvaTypeMap[CARDINALITY] = 2;
+selvaTypeMap[JSON] = 2;
+selvaTypeMap[STRING] = 2;
+selvaTypeMap[TEXT] = 3;
+selvaTypeMap[REFERENCE] = 4;
+selvaTypeMap[REFERENCES] = 5;
+selvaTypeMap[WEAK_REFERENCE] = 6;
+selvaTypeMap[WEAK_REFERENCES] = 7;
+selvaTypeMap[ALIAS] = 8;
+selvaTypeMap[ALIASES] = 9;
+const EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT = 0x01;
+function blockCapacity(blockCapacity) {
+    const buf = new Uint8Array(Uint32Array.BYTES_PER_ELEMENT);
+    const view = new DataView(buf.buffer);
+    view.setUint32(0, blockCapacity, true);
+    return buf;
+}
+function sepPropCount(props) {
+    return props.filter((prop) => prop.separate).length;
+}
+function makeEdgeConstraintFlags(prop) {
+    return prop.dependent ? EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT : 0x00;
+}
+const propDefBuffer = (schema, prop, isEdge) => {
+    const type = prop.typeIndex;
+    const selvaType = selvaTypeMap[type];
+    if (prop.len && (type === MICRO_BUFFER || type === VECTOR)) {
+        const buf = new Uint8Array(3);
+        const view = new DataView(buf.buffer);
+        buf[0] = selvaType;
+        view.setUint16(1, prop.len, true);
+        return [...buf];
+    }
+    else if (type === REFERENCE || type === REFERENCES) {
+        const buf = new Uint8Array(9);
+        const view = new DataView(buf.buffer);
+        const dstType = schema[prop.inverseTypeName];
+        let eschema = [];
+        // @ts-ignore
+        buf[0] = selvaType + 2 * !!isEdge; // field type
+        buf[1] = makeEdgeConstraintFlags(prop); // flags
+        view.setUint16(2, dstType.id, true); // dst_node_type
+        view.setUint32(5, 0, true); // schema_len
+        if (!isEdge) {
+            prop.inverseTypeId = dstType.id;
+            prop.inversePropNumber = dstType.props[prop.inversePropName].prop;
+            buf[4] = prop.inversePropNumber;
+            if (prop.edges) {
+                const edgesS = Object.values(prop.edges);
+                if (edgesS.length) {
+                    const props = edgesS
+                        .filter((v) => v.separate === true)
+                        .sort((a, b) => (a.prop > b.prop ? 1 : -1));
+                    const p = [
+                        {
+                            ...EMPTY_MICRO_BUFFER,
+                            len: prop.edgeMainLen || 1, // allow zero here... else useless padding
+                            __isEdgeDef: true,
+                        },
+                        // or handle this here...
+                        ...props,
+                    ];
+                    eschema = p
+                        .map((prop) => propDefBuffer(schema, prop, true))
+                        .flat(1);
+                    eschema.unshift(0, 0, 0, 0, sepPropCount(p), 0);
+                    view.setUint32(5, eschema.length, true);
+                }
+            }
+        }
+        return [...buf, ...eschema];
+    }
+    else if (type === STRING ||
+        type === BINARY ||
+        type === CARDINALITY ||
+        type === JSON) {
+        return [selvaType, prop.len < 50 ? prop.len : 0];
+    }
+    {
+        return [selvaType];
+    }
+};
+// TODO rewrite
+export function schemaToSelvaBuffer(schema) {
+    return Object.values(schema).map((t, i) => {
+        const props = Object.values(t.props);
+        const rest = [];
+        let refFields = 0;
+        for (const f of props) {
+            if (f.separate) {
+                if (f.typeIndex === REFERENCE || f.typeIndex === REFERENCES) {
+                    refFields++;
+                }
+                rest.push(f);
+            }
+        }
+        rest.sort((a, b) => a.prop - b.prop);
+        return Uint8Array.from([
+            ...blockCapacity(t.blockCapacity),
+            1 + sepPropCount(props),
+            1 + refFields,
+            ...propDefBuffer(schema, {
+                ...EMPTY_MICRO_BUFFER,
+                len: t.mainLen === 0 ? 1 : t.mainLen,
+            }),
+            ...rest.map((f) => propDefBuffer(schema, f)).flat(1),
+        ]).buffer;
+    });
+}
+//# sourceMappingURL=selvaBuffer.js.map

package/dist/def/typeDef.d.ts

@@ -0,0 +1,7 @@
+import { SchemaObject, StrictSchemaType, SchemaLocales } from '../index.js';
+import { SchemaTypeDef, SchemaTypesParsedById, SchemaTypesParsed } from './types.js';
+import { StrictSchema } from '../types.js';
+export declare const DEFAULT_BLOCK_CAPACITY = 100000;
+export declare const updateTypeDefs: (schema: StrictSchema, schemaTypesParsed: SchemaTypesParsed, schemaTypesParsedById: SchemaTypesParsedById) => void;
+export declare const createSchemaTypeDef: (typeName: string, type: StrictSchemaType | SchemaObject, parsed: SchemaTypesParsed, locales: Partial<SchemaLocales>, result?: Partial<SchemaTypeDef>, path?: string[], top?: boolean) => SchemaTypeDef;
+//# sourceMappingURL=typeDef.d.ts.map

package/dist/def/typeDef.js

@@ -0,0 +1,215 @@
+import { isPropType, getPropType, } from '../index.js';
+import { setByPath } from '@saulx/utils';
+import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, NUMBER, } from './types.js';
+import { DEFAULT_MAP } from './defaultMap.js';
+import { makePacked } from './makePacked.js';
+import { makeSeparateTextSort } from './makeSeparateTextSort.js';
+import { makeSeparateSort } from './makeSeparateSort.js';
+import { getPropLen } from './getPropLen.js';
+import { isSeparate, parseMinMaxStep } 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) {
+        if (field in schema.types) {
+            continue;
+        }
+        const id = schemaTypesParsed[field].id;
+        delete schemaTypesParsed[field];
+        delete schemaTypesParsedById[id];
+    }
+    for (const field in schema.types) {
+        const type = schema.types[field];
+        if (schemaTypesParsed[field] &&
+            schemaTypesParsed[field].checksum === hashObjectIgnoreKeyOrder(type) // bit weird..
+        ) {
+            continue;
+        }
+        else {
+            if (!type.id) {
+                throw new Error('NEED ID ON TYPE');
+            }
+            const def = createSchemaTypeDef(field, type, schemaTypesParsed, schema.locales ?? {
+                en: {},
+            });
+            // TODO this should come from somewhere else
+            def.blockCapacity =
+                field === '_root' ? 2147483647 : DEFAULT_BLOCK_CAPACITY;
+            schemaTypesParsed[field] = def;
+            schemaTypesParsedById[type.id] = def;
+        }
+    }
+};
+export const createSchemaTypeDef = (typeName, type, parsed, locales, result = createEmptyDef(typeName, type, locales), path = [], top = true) => {
+    if (result.id == 0 && top) {
+        if ('id' in type) {
+            result.id = type.id;
+        }
+        else {
+            throw new Error(`Invalid schema type id ${result.type}`);
+        }
+    }
+    result.locales = locales;
+    result.localeSize = Object.keys(locales).length;
+    result.idUint8[0] = result.id & 255;
+    result.idUint8[1] = result.id >> 8;
+    const target = type.props;
+    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);
+        if (propType === 'object') {
+            createSchemaTypeDef(typeName, schemaProp, parsed, locales, result, propPath, false);
+        }
+        else {
+            const len = getPropLen(schemaProp);
+            if (isPropType('string', schemaProp) ||
+                isPropType('alias', schemaProp) ||
+                isPropType('cardinality', schemaProp)) {
+                if (typeof schemaProp === 'object') {
+                    if (!(schemaProp.maxBytes < 61) ||
+                        !('max' in schemaProp && schemaProp.max < 31)) {
+                        separateSortProps++;
+                    }
+                }
+                else {
+                    separateSortProps++;
+                }
+            }
+            else if (isPropType('text', schemaProp)) {
+                separateSortText++;
+            }
+            const isseparate = isSeparate(schemaProp, len);
+            const typeIndex = TYPE_INDEX_MAP[propType];
+            const prop = {
+                typeIndex,
+                __isPropDef: true,
+                separate: isseparate,
+                path: propPath,
+                start: 0,
+                validation: schemaProp.validation ??
+                    VALIDATION_MAP[typeIndex] ??
+                    defaultValidation,
+                len,
+                default: schemaProp.default ?? DEFAULT_MAP[typeIndex],
+                prop: isseparate ? ++result.cnt : 0,
+            };
+            if (schemaProp.max !== undefined) {
+                prop.max = parseMinMaxStep(schemaProp.max);
+            }
+            if (schemaProp.min !== undefined) {
+                prop.min = parseMinMaxStep(schemaProp.min);
+            }
+            if (schemaProp.step !== undefined) {
+                prop.step = parseMinMaxStep(schemaProp.step);
+            }
+            if (prop.typeIndex !== NUMBER && prop.step === undefined) {
+                prop.step = 1;
+            }
+            if (isPropType('enum', schemaProp)) {
+                prop.enum = Array.isArray(schemaProp) ? schemaProp : schemaProp.enum;
+                prop.reverseEnum = {};
+                for (let i = 0; i < prop.enum.length; i++) {
+                    prop.reverseEnum[prop.enum[i]] = i;
+                }
+            }
+            else if (isPropType('references', schemaProp)) {
+                prop.inversePropName = schemaProp.items.prop;
+                prop.inverseTypeName = schemaProp.items.ref;
+                prop.dependent = schemaProp.items.dependent;
+                addEdges(prop, schemaProp.items);
+            }
+            else if (isPropType('reference', schemaProp)) {
+                prop.inversePropName = schemaProp.prop;
+                prop.inverseTypeName = schemaProp.ref;
+                prop.dependent = schemaProp.dependent;
+                addEdges(prop, schemaProp);
+            }
+            else if (typeof schemaProp === 'object') {
+                if (isPropType('string', schemaProp) ||
+                    isPropType('text', schemaProp)) {
+                    prop.compression =
+                        'compression' in schemaProp && schemaProp.compression === 'none'
+                            ? 0
+                            : 1;
+                }
+                else if (isPropType('timestamp', schemaProp) && 'on' in schemaProp) {
+                    if (schemaProp.on[0] === 'c') {
+                        result.createTs ??= [];
+                        result.createTs.push(prop);
+                    }
+                    else if (schemaProp.on[0] === 'u') {
+                        result.createTs ??= [];
+                        result.createTs.push(prop);
+                        result.updateTs ??= [];
+                        result.updateTs.push(prop);
+                    }
+                }
+            }
+            result.props[propPath.join('.')] = prop;
+            if (isseparate) {
+                result.separate.push(prop);
+            }
+        }
+    }
+    if (top) {
+        // Put top level together
+        const vals = Object.values(result.props);
+        vals.sort((a, b) => {
+            if (b.separate &&
+                (a.typeIndex === REFERENCES || a.typeIndex === REFERENCE)) {
+                return -1;
+            }
+            return a.prop - b.prop;
+        });
+        let lastProp = 0;
+        for (const p of vals) {
+            if (p.separate) {
+                p.prop = ++lastProp;
+            }
+        }
+        let len = 2;
+        for (const f of vals) {
+            if (f.separate) {
+                len += 2;
+                setByPath(result.tree, f.path, f);
+            }
+            else {
+                if (!result.mainLen) {
+                    len += 2;
+                }
+                len += 1;
+                f.start = result.mainLen;
+                result.mainLen += f.len;
+                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);
+        }
+        if (separateSortProps > 0) {
+            makeSeparateSort(result);
+        }
+        for (const p in result.props) {
+            const x = result.props[p];
+            if (!x.separate) {
+                result.main[x.start] = x;
+            }
+            else {
+                result.reverseProps[x.prop] = x;
+            }
+        }
+    }
+    return result;
+};
+//# sourceMappingURL=typeDef.js.map

package/dist/def/types.d.ts

@@ -0,0 +1,168 @@
+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 NUMBER = 4;
+export declare const CARDINALITY = 5;
+export declare const INT8 = 20;
+export declare const UINT8 = 6;
+export declare const INT16 = 21;
+export declare const UINT16 = 22;
+export declare const INT32 = 23;
+export declare const UINT32 = 7;
+export declare const BOOLEAN = 9;
+export declare const ENUM = 10;
+export declare const STRING = 11;
+export declare const TEXT = 12;
+export declare const REFERENCE = 13;
+export declare const REFERENCES = 14;
+export declare const WEAK_REFERENCE = 15;
+export declare const WEAK_REFERENCES = 16;
+export declare const MICRO_BUFFER = 17;
+export declare const ALIAS = 18;
+export declare const ALIASES = 19;
+export declare const BINARY = 25;
+export declare const ID = 26;
+export declare const VECTOR = 27;
+export declare const JSON = 28;
+export declare const OBJECT = 29;
+export declare const TYPE_INDEX_MAP: {
+    alias: number;
+    aliases: number;
+    microbuffer: number;
+    references: number;
+    reference: number;
+    timestamp: number;
+    boolean: number;
+    number: number;
+    string: number;
+    text: number;
+    uint16: number;
+    uint32: number;
+    int16: number;
+    int32: number;
+    uint8: number;
+    enum: number;
+    int8: number;
+    id: number;
+    binary: number;
+    vector: number;
+    cardinality: number;
+    json: number;
+    object: number;
+};
+export type InternalSchemaProp = keyof typeof TYPE_INDEX_MAP;
+export type TypeIndex = (typeof TYPE_INDEX_MAP)[InternalSchemaProp];
+export type PropDef = {
+    __isPropDef: true;
+    prop: number;
+    typeIndex: TypeIndex;
+    separate: boolean;
+    path: string[];
+    start: number;
+    len: number;
+    inverseTypeName?: string;
+    inversePropName?: string;
+    compression?: 0 | 1;
+    inverseTypeId?: number;
+    inversePropNumber?: number;
+    enum?: any[];
+    dependent?: boolean;
+    validation: Validation;
+    default: any;
+    edgeMainLen?: 0;
+    reverseEnum?: {
+        [key: string]: number;
+    };
+    edgesSeperateCnt?: number;
+    edges?: {
+        [key: string]: PropDefEdge;
+    };
+    reverseSeperateEdges?: {
+        [prop: string]: PropDefEdge;
+    };
+    reverseMainEdges?: {
+        [start: string]: PropDefEdge;
+    };
+    edgeMainEmpty?: Uint8Array;
+    __isEdge?: boolean;
+    max?: any;
+    min?: any;
+    step?: any;
+};
+export type PropDefEdge = Partial<PropDef> & {
+    __isPropDef: true;
+    typeIndex: TypeIndex;
+    len: number;
+    prop: number;
+    name: string;
+    edgesTotalLen?: number;
+    __isEdge: true;
+};
+export type PropDefAggregate = Partial<PropDef> & {
+    __isPropDef: true;
+    typeIndex: TypeIndex;
+    len: number;
+    prop: number;
+    name: string;
+};
+export type SchemaPropTree = {
+    [key: string]: SchemaPropTree | PropDef;
+};
+export type SchemaSortUndefinedHandler = {
+    size: number;
+    buffer: Uint8Array;
+    bufferTmp: Uint8Array;
+    props: PropDef[];
+};
+export type SchemaTypeDef = {
+    cnt: number;
+    checksum: number;
+    total: number;
+    type: string;
+    lastId: number;
+    blockCapacity: number;
+    mainLen: number;
+    buf: Uint8Array;
+    propNames: Uint8Array;
+    packed: Uint8Array;
+    props: {
+        [path: string]: PropDef;
+    };
+    reverseProps: {
+        [field: string]: PropDef;
+    };
+    id: number;
+    idUint8: Uint8Array;
+    separate: PropDef[];
+    main: {
+        [start: string]: PropDef;
+    };
+    mainEmpty: Uint8Array;
+    mainEmptyAllZeroes: boolean;
+    tree: SchemaPropTree;
+    hasSeperateSort: boolean;
+    seperateSort: SchemaSortUndefinedHandler;
+    hasSeperateTextSort: boolean;
+    seperateTextSort: SchemaSortUndefinedHandler & {
+        noUndefined: Uint8Array;
+        localeStringToIndex: Map<string, Uint8Array>;
+        localeToIndex: Map<LangCode, number>;
+    };
+    createTs?: PropDef[];
+    updateTs?: PropDef[];
+    locales: Partial<SchemaLocales>;
+    localeSize: number;
+};
+export declare const SIZE_MAP: Record<InternalSchemaProp, 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;
+export declare const getPropTypeName: (propType: TypeIndex) => InternalSchemaProp;
+export declare const isPropDef: (prop: any) => prop is PropDef;
+export type SchemaTypesParsed = {
+    [key: string]: SchemaTypeDef;
+};
+export type SchemaTypesParsedById = Record<number, SchemaTypeDef>;
+//# sourceMappingURL=types.d.ts.map

package/dist/def/types.js

@@ -0,0 +1,119 @@
+// 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 NUMBER = 4;
+export const CARDINALITY = 5;
+export const INT8 = 20;
+export const UINT8 = 6;
+export const INT16 = 21;
+export const UINT16 = 22;
+export const INT32 = 23;
+export const UINT32 = 7;
+export const BOOLEAN = 9;
+export const ENUM = 10;
+export const STRING = 11;
+export const TEXT = 12;
+export const REFERENCE = 13;
+export const REFERENCES = 14;
+export const WEAK_REFERENCE = 15;
+export const WEAK_REFERENCES = 16;
+export const MICRO_BUFFER = 17;
+export const ALIAS = 18;
+export const ALIASES = 19;
+export const BINARY = 25;
+export const ID = 26;
+export const VECTOR = 27;
+export const JSON = 28;
+export const OBJECT = 29;
+export const TYPE_INDEX_MAP = {
+    alias: ALIAS,
+    aliases: ALIASES,
+    microbuffer: MICRO_BUFFER,
+    references: REFERENCES,
+    reference: REFERENCE,
+    timestamp: TIMESTAMP,
+    boolean: BOOLEAN,
+    number: NUMBER,
+    string: STRING,
+    text: TEXT,
+    uint16: UINT16,
+    uint32: UINT32,
+    int16: INT16,
+    int32: INT32,
+    uint8: UINT8,
+    enum: ENUM,
+    int8: INT8,
+    id: NULL,
+    binary: BINARY,
+    vector: VECTOR,
+    cardinality: CARDINALITY,
+    json: JSON,
+    object: OBJECT,
+};
+export const SIZE_MAP = {
+    timestamp: 8, // 64bit
+    // double-precision 64-bit binary format IEEE 754 value
+    number: 8, // 64bit
+    int8: 1,
+    uint8: 1,
+    int16: 2,
+    uint16: 2,
+    int32: 4,
+    uint32: 4,
+    boolean: 1,
+    reference: 0, // separate
+    enum: 1, // enum
+    string: 0, // separate
+    text: 0, // separate
+    cardinality: 0, // separate
+    references: 0, // separate
+    microbuffer: 0, // separate
+    alias: 0,
+    aliases: 0,
+    id: 4,
+    binary: 0,
+    vector: 0, // separate
+    json: 0,
+    object: 0,
+};
+const reverseMap = {};
+for (const k in TYPE_INDEX_MAP) {
+    reverseMap[TYPE_INDEX_MAP[k]] = k;
+}
+export const REVERSE_SIZE_MAP = {};
+for (const k in SIZE_MAP) {
+    REVERSE_SIZE_MAP[TYPE_INDEX_MAP[k]] = SIZE_MAP[k];
+}
+export const REVERSE_TYPE_INDEX_MAP = reverseMap;
+export const ID_FIELD_DEF = {
+    typeIndex: TYPE_INDEX_MAP['id'],
+    separate: true,
+    path: ['id'],
+    start: 0,
+    prop: 255,
+    default: 0,
+    len: 4,
+    validation: () => true,
+    __isPropDef: true,
+};
+export const EMPTY_MICRO_BUFFER = {
+    typeIndex: TYPE_INDEX_MAP['microbuffer'],
+    separate: true,
+    path: [''],
+    start: 0,
+    default: undefined,
+    prop: 0,
+    len: 1,
+    validation: () => true,
+    __isPropDef: true,
+};
+export const getPropTypeName = (propType) => {
+    return REVERSE_TYPE_INDEX_MAP[propType];
+};
+export const isPropDef = (prop) => {
+    if ('__isPropDef' in prop && prop.__isPropDef === true) {
+        return true;
+    }
+    return false;
+};
+//# sourceMappingURL=types.js.map

package/dist/def/utils.d.ts

@@ -0,0 +1,8 @@
+import { PropDef, PropDefEdge } from './types.js';
+import { SchemaProp } from '../types.js';
+export declare function isSeparate(schemaProp: SchemaProp, len: number): boolean;
+export declare const propIsSigned: (prop: PropDef | PropDefEdge) => boolean;
+export declare const propIsNumerical: (prop: PropDef | PropDefEdge) => boolean;
+export declare function getPropLen(schemaProp: SchemaProp): any;
+export declare const parseMinMaxStep: (val: any) => string | number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/def/utils.js

@@ -0,0 +1,59 @@
+import { INT16, INT32, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, SIZE_MAP, } from './types.js';
+import { isPropType } from '../types.js';
+import { getPropType } from '../parse/utils.js';
+import { convertToTimestamp } from '@saulx/utils';
+export function isSeparate(schemaProp, len) {
+    return len === 0 || isPropType('vector', schemaProp);
+}
+export const propIsSigned = (prop) => {
+    const t = prop.typeIndex;
+    if (t === INT16 || t === INT32 || t === INT8) {
+        return true;
+    }
+    return false;
+};
+export const propIsNumerical = (prop) => {
+    const t = prop.typeIndex;
+    if (t === INT16 ||
+        t === INT32 ||
+        t === INT8 ||
+        t === UINT8 ||
+        t === UINT16 ||
+        t === UINT32 ||
+        t === NUMBER ||
+        t === TIMESTAMP) {
+        return true;
+    }
+    return false;
+};
+export function getPropLen(schemaProp) {
+    let len = SIZE_MAP[getPropType(schemaProp)];
+    if (isPropType('string', schemaProp) ||
+        isPropType('alias', schemaProp) ||
+        isPropType('cardinality', schemaProp)) {
+        if (typeof schemaProp === 'object') {
+            if (schemaProp.maxBytes < 61) {
+                len = schemaProp.maxBytes + 1;
+            }
+            else if ('max' in schemaProp && schemaProp.max < 31) {
+                len = schemaProp.max * 2 + 1;
+            }
+        }
+    }
+    else if (isPropType('vector', schemaProp)) {
+        len = 4 * schemaProp.size;
+    }
+    return len;
+}
+export const parseMinMaxStep = (val) => {
+    if (typeof val === 'number') {
+        return val;
+    }
+    if (typeof val === 'string') {
+        if (!val.includes('now')) {
+            return convertToTimestamp(val);
+        }
+        return val;
+    }
+};
+//# sourceMappingURL=utils.js.map

package/dist/def/validation.d.ts

@@ -0,0 +1,7 @@
+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;
+export declare const isValidId: (id: number) => boolean;
+export declare const isValidString: (v: any) => boolean;
+//# sourceMappingURL=validation.d.ts.map