@based/schema 5.0.0-alpha.3 → 5.0.0-alpha.5

package/dist/def/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './typeDef.js';
+export * from './utils.js';
+export * from './selvaBuffer.js';
+export * from './readFromPacked.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/def/index.js

@@ -0,0 +1,7 @@
+// flap
+export * from './types.js';
+export * from './typeDef.js';
+export * from './utils.js';
+export * from './selvaBuffer.js';
+export * from './readFromPacked.js';
+//# sourceMappingURL=index.js.map

package/dist/def/readFromPacked.d.ts

@@ -0,0 +1,3 @@
+import { SchemaTypeDef } from './types.js';
+export declare const readFromPacked: (packed: Uint8Array) => SchemaTypeDef;
+//# sourceMappingURL=readFromPacked.d.ts.map

package/dist/def/readFromPacked.js

@@ -0,0 +1,126 @@
+import { REVERSE_SIZE_MAP } from './types.js';
+export const readFromPacked = (packed) => {
+    const size = (packed[0] | (packed[1] << 8)) >>> 0;
+    const props = [];
+    const b = packed.subarray(2, 2 + size);
+    let collectMain = false;
+    const mainProps = [];
+    const typeId = b.subarray(0, 2);
+    const typeIdNr = (typeId[0] | (typeId[1] << 8)) >>> 0;
+    for (let i = 2; i < b.length; i++) {
+        const prop = b[i];
+        if (collectMain) {
+            if (prop === 0) {
+                collectMain = false;
+            }
+            else {
+                mainProps.push({
+                    prop: 0,
+                    typeIndex: b[i],
+                });
+            }
+        }
+        else {
+            if (prop == 0) {
+                collectMain = true;
+            }
+            else {
+                props.push({ prop, typeIndex: b[i + 1] });
+                i++;
+            }
+        }
+    }
+    const decoder = new TextDecoder();
+    const fields = [];
+    const f = packed.subarray(2 + size, packed.length);
+    for (let i = 0; i < f.length; i++) {
+        const size = f[i];
+        fields.push(decoder.decode(f.subarray(i + 1, i + 1 + size)));
+        i += size;
+    }
+    for (let i = 0; i < mainProps.length; i++) {
+        mainProps[i].path = fields[i + 1];
+    }
+    for (let i = 0; i < props.length; i++) {
+        props[i].path = fields[i + 1 + mainProps.length];
+    }
+    // Fixed len strings not supported
+    // Refs also not supported
+    // Text not supported yet
+    // Ref not supported yet
+    //   compression: 1 (0)
+    // YET
+    const result = {
+        cnt: 0,
+        checksum: 0,
+        total: 0,
+        type: fields[0],
+        lastId: 0,
+        blockCapacity: 0,
+        mainLen: mainProps.length,
+        buf: b,
+        propNames: f,
+        packed,
+        props: {},
+        reverseProps: {}, // in a bit
+        id: typeIdNr,
+        idUint8: typeId,
+        separate: [],
+        main: {},
+        tree: {},
+        // not nessecary...
+        hasSeperateSort: false,
+        seperateSort: {
+            size: 0,
+            buffer: new Uint8Array([]),
+            bufferTmp: new Uint8Array([]),
+            props: [],
+        },
+        hasSeperateTextSort: false,
+        seperateTextSort: {
+            size: 0,
+            buffer: new Uint8Array([]),
+            bufferTmp: new Uint8Array([]),
+            props: [],
+        },
+        // need this...
+        locales: {},
+        localeSize: 0,
+    };
+    let s = 0;
+    for (const p of mainProps) {
+        const len = REVERSE_SIZE_MAP[p.typeIndex];
+        result.props[p.path] = {
+            prop: p.prop,
+            separate: false,
+            __isPropDef: true,
+            start: s,
+            typeIndex: p.typeIndex,
+            path: p.path.split('.'),
+            len,
+        };
+        s += len;
+    }
+    for (const p of props) {
+        result.props[p.path] = {
+            prop: p.prop,
+            separate: true,
+            __isPropDef: true,
+            start: 0,
+            typeIndex: p.typeIndex,
+            path: p.path.split('.'),
+            len: 0,
+            compression: 1,
+        };
+    }
+    // make this into a typeDef
+    //   return {
+    //     type: fields[0],
+    //     fields,
+    //     typeId,
+    //     props,
+    //     mainProps,
+    //   }
+    return result;
+};
+//# sourceMappingURL=readFromPacked.js.map

package/dist/def/selvaBuffer.d.ts

@@ -0,0 +1,5 @@
+import { SchemaTypeDef } from './types.js';
+export declare function schemaToSelvaBuffer(schema: {
+    [key: string]: SchemaTypeDef;
+}): Buffer[];
+//# sourceMappingURL=selvaBuffer.d.ts.map

package/dist/def/selvaBuffer.js

@@ -0,0 +1,115 @@
+import { ALIAS, ALIASES, BINARY, BOOLEAN, CREATED, EMPTY_MICRO_BUFFER, ENUM, CARDINALITY, INT16, INT32, INT8, MICRO_BUFFER, NULL, NUMBER, REFERENCE, REFERENCES, STRING, TEXT, TIMESTAMP, UINT16, UINT32, UINT8, UPDATED, VECTOR, WEAK_REFERENCE, WEAK_REFERENCES, JSON, } from './types.js';
+const selvaTypeMap = [];
+selvaTypeMap[NULL] = 0;
+selvaTypeMap[TIMESTAMP] = 4;
+selvaTypeMap[CREATED] = 1;
+selvaTypeMap[UPDATED] = 1;
+selvaTypeMap[NUMBER] = 4;
+selvaTypeMap[CARDINALITY] = 11;
+selvaTypeMap[INT8] = 20;
+selvaTypeMap[UINT8] = 6;
+selvaTypeMap[INT16] = 21;
+selvaTypeMap[UINT16] = 22;
+selvaTypeMap[INT32] = 23;
+selvaTypeMap[UINT32] = 7;
+selvaTypeMap[BOOLEAN] = 9;
+selvaTypeMap[ENUM] = 10;
+selvaTypeMap[STRING] = 11;
+selvaTypeMap[TEXT] = 12;
+selvaTypeMap[REFERENCE] = 13;
+selvaTypeMap[REFERENCES] = 14;
+selvaTypeMap[WEAK_REFERENCE] = 15;
+selvaTypeMap[WEAK_REFERENCES] = 16;
+selvaTypeMap[MICRO_BUFFER] = 17;
+selvaTypeMap[ALIAS] = 18;
+selvaTypeMap[ALIASES] = 19;
+selvaTypeMap[BINARY] = 11;
+selvaTypeMap[VECTOR] = 17;
+selvaTypeMap[JSON] = 11;
+const EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT = 0x01;
+function blockCapacity(blockCapacity) {
+    const buf = Buffer.allocUnsafe(4);
+    buf.writeInt32LE(blockCapacity);
+    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 = Buffer.allocUnsafe(3);
+        buf[0] = selvaType;
+        buf.writeUint16LE(prop.len, 1);
+        return [...buf.values()];
+    }
+    else if (type === REFERENCE || type === REFERENCES) {
+        const buf = Buffer.allocUnsafe(9);
+        const dstType = schema[prop.inverseTypeName];
+        let eschema = [];
+        // @ts-ignore
+        buf[0] = selvaType + 2 * !!isEdge; // field type
+        buf[1] = makeEdgeConstraintFlags(prop); // flags
+        buf.writeUInt16LE(dstType.id, 2); // dst_node_type
+        buf.writeUint32LE(0, 5); // schema_len
+        if (!isEdge) {
+            prop.inverseTypeId = dstType.id;
+            prop.inversePropNumber = dstType.props[prop.inversePropName].prop;
+            buf[4] = prop.inversePropNumber;
+            if (prop.edges) {
+                const props = Object.values(prop.edges);
+                eschema = props
+                    .map((prop) => propDefBuffer(schema, prop, true))
+                    .flat(1);
+                eschema.unshift(0, 0, 0, 0, sepPropCount(props), 0);
+                buf.writeUint32LE(eschema.length, 5);
+            }
+        }
+        return [...buf.values(), ...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) {
+    if (typeof Buffer === 'undefined') {
+        // TMP
+        return [];
+    }
+    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 Buffer.from([
+            ...blockCapacity(t.blockCapacity).values(),
+            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),
+        ]);
+    });
+}
+//# 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,376 @@
+import { isPropType, getPropType, } from '../index.js';
+import { setByPath } from '@saulx/utils';
+import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
+import { SIZE_MAP, TYPE_INDEX_MAP, STRING, ALIAS, CARDINALITY, REFERENCES, REFERENCE, TEXT, ENUM, } from './types.js';
+// TMP
+export const DEFAULT_BLOCK_CAPACITY = 100_000;
+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;
+}
+function isSeparate(schemaProp, len) {
+    return len === 0 || isPropType('vector', schemaProp);
+}
+const addEdges = (prop, refProp) => {
+    let edgesCnt = 0;
+    for (const key in refProp) {
+        if (key[0] === '$') {
+            if (!prop.edges) {
+                prop.edges = {};
+                prop.reverseEdges = {};
+                prop.edgesTotalLen = 0;
+            }
+            edgesCnt++;
+            const edgeType = getPropType(refProp[key]);
+            const edge = {
+                __isPropDef: true,
+                __isEdge: true,
+                prop: edgesCnt,
+                name: key,
+                typeIndex: TYPE_INDEX_MAP[edgeType],
+                len: SIZE_MAP[edgeType],
+                separate: true,
+                path: [...prop.path, key],
+            };
+            if (edge.len == 0) {
+                prop.edgesTotalLen = 0;
+            }
+            else {
+                // [field] [size] [data]
+                prop.edgesTotalLen += 1 + 2 + edge.len; // field len
+            }
+            if (edge.typeIndex === ENUM) {
+                edge.enum = Array.isArray(refProp[key])
+                    ? refProp[key]
+                    : refProp[key].enum;
+                edge.reverseEnum = {};
+                for (let i = 0; i < edge.enum.length; i++) {
+                    edge.reverseEnum[edge.enum[i]] = i;
+                }
+            }
+            else if (edge.typeIndex === REFERENCES) {
+                edge.inverseTypeName = refProp[key].items.ref;
+            }
+            else if (edge.typeIndex === REFERENCE) {
+                edge.inverseTypeName = refProp[key].ref;
+            }
+            prop.edges[key] = edge;
+            prop.reverseEdges[edge.prop] = edge;
+        }
+    }
+};
+function makePacked(result, typeName, vals, len) {
+    const encoder = new TextEncoder();
+    result.buf = new Uint8Array(len);
+    result.buf[0] = result.idUint8[0];
+    result.buf[1] = result.idUint8[1];
+    const fieldNames = [];
+    const tNameBuf = encoder.encode(typeName);
+    fieldNames.push(tNameBuf);
+    let fieldNameLen = tNameBuf.byteLength + 1;
+    let i = 2;
+    if (result.mainLen) {
+        result.buf[i] = 0;
+        for (const f of vals) {
+            if (!f.separate) {
+                i++;
+                result.buf[i] = f.typeIndex;
+                const name = encoder.encode(f.path.join('.'));
+                fieldNames.push(name);
+                fieldNameLen += name.byteLength + 1;
+            }
+        }
+        i++;
+        result.buf[i] = 0;
+    }
+    for (const f of vals) {
+        if (f.separate) {
+            i++;
+            result.buf[i] = f.prop;
+            i++;
+            result.buf[i] = f.typeIndex;
+            const name = encoder.encode(f.path.join('.'));
+            fieldNames.push(name);
+            fieldNameLen += name.byteLength + 1;
+        }
+    }
+    result.propNames = new Uint8Array(fieldNameLen);
+    let lastWritten = 0;
+    for (const f of fieldNames) {
+        result.propNames[lastWritten] = f.byteLength;
+        result.propNames.set(f, lastWritten + 1);
+        lastWritten += f.byteLength + 1;
+    }
+    let bufLen = result.buf.length;
+    result.packed = new Uint8Array(2 + bufLen + result.propNames.length);
+    result.packed[0] = bufLen;
+    result.packed[1] = bufLen >>>= 8;
+    result.packed.set(result.buf, 2);
+    result.packed.set(result.propNames, result.buf.length + 2);
+}
+function makeSeparateTextSort(result) {
+    result.hasSeperateTextSort = true;
+    let max = 0;
+    for (const f of result.separate) {
+        if (f.typeIndex === TEXT) {
+            if (f.prop > max) {
+                max = f.prop;
+            }
+        }
+    }
+    result.seperateTextSort.buffer = new Uint8Array(max * result.localeSize + 1);
+    for (const f of result.separate) {
+        if (f.typeIndex === TEXT) {
+            result.seperateTextSort.buffer[f.prop] = 1;
+            result.seperateTextSort.props.push(f);
+            result.seperateTextSort.size += result.localeSize;
+        }
+    }
+    result.seperateTextSort.bufferTmp = new Uint8Array(max * result.localeSize + 1);
+    result.seperateTextSort.buffer.set(result.seperateTextSort.bufferTmp);
+}
+function makeSeparateSort(result) {
+    result.hasSeperateSort = true;
+    let max = 0;
+    for (const f of result.separate) {
+        if (f.typeIndex === STRING ||
+            f.typeIndex === ALIAS ||
+            f.typeIndex === CARDINALITY) {
+            if (f.prop > max) {
+                max = f.prop;
+            }
+        }
+    }
+    result.seperateSort.buffer = new Uint8Array(max + 1);
+    for (const f of result.separate) {
+        if (f.typeIndex === STRING ||
+            f.typeIndex === ALIAS ||
+            f.typeIndex === CARDINALITY) {
+            result.seperateSort.buffer[f.prop] = 1;
+            result.seperateSort.props.push(f);
+            result.seperateSort.size++;
+        }
+    }
+    result.seperateSort.bufferTmp = new Uint8Array(max + 1);
+    result.seperateSort.buffer.set(result.seperateSort.bufferTmp);
+}
+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: {},
+            });
+            def.blockCapacity =
+                field === '_root' ? 2147483647 : DEFAULT_BLOCK_CAPACITY; // TODO this should come from somewhere else
+            schemaTypesParsed[field] = def;
+            schemaTypesParsedById[type.id] = def;
+        }
+    }
+};
+export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
+    cnt: 0,
+    checksum: hashObjectIgnoreKeyOrder(type),
+    type: typeName,
+    props: {},
+    reverseProps: {},
+    idUint8: new Uint8Array([0, 0]),
+    id: 0,
+    mainLen: 0,
+    separate: [],
+    tree: {},
+    total: 0,
+    lastId: 0,
+    main: {},
+    hasSeperateSort: false,
+    seperateSort: {
+        size: 0,
+        props: [],
+        buffer: new Uint8Array([]),
+        bufferTmp: new Uint8Array([]),
+    },
+    hasSeperateTextSort: false,
+    seperateTextSort: {
+        size: 0, // prop len
+        props: [],
+        buffer: new Uint8Array([]),
+        bufferTmp: new Uint8Array([]),
+    },
+}, 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) {
+        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 prop = {
+                typeIndex: TYPE_INDEX_MAP[propType],
+                __isPropDef: true,
+                separate: isseparate,
+                path: propPath,
+                start: 0,
+                len,
+                prop: isseparate ? ++result.cnt : 0,
+            };
+            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) {
+        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);
+            }
+        }
+        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,146 @@
+import type { SchemaLocales } from '../index.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;
+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 TYPE_INDEX_MAP: {
+    alias: number;
+    aliases: number;
+    microbuffer: number;
+    references: number;
+    reference: number;
+    timestamp: number;
+    boolean: number;
+    created: number;
+    updated: 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;
+};
+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[];
+    reverseEnum?: {
+        [key: string]: number;
+    };
+    edgesTotalLen?: number;
+    edges?: {
+        [key: string]: PropDefEdge;
+    };
+    reverseEdges?: {
+        [prop: string]: PropDefEdge;
+    };
+    __isEdge?: boolean;
+    dependent?: boolean;
+};
+export type PropDefEdge = Partial<PropDef> & {
+    __isPropDef: true;
+    typeIndex: TypeIndex;
+    len: number;
+    prop: number;
+    name: string;
+    edgesTotalLen?: number;
+    __isEdge: true;
+};
+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;
+    };
+    tree: SchemaPropTree;
+    hasSeperateSort: boolean;
+    seperateSort: SchemaSortUndefinedHandler;
+    hasSeperateTextSort: boolean;
+    seperateTextSort: SchemaSortUndefinedHandler;
+    createTs?: PropDef[];
+    updateTs?: PropDef[];
+    locales: Partial<SchemaLocales>;
+    localeSize: number;
+};
+export declare const SIZE_MAP: Record<InternalSchemaProp, number>;
+export declare let 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,120 @@
+// 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;
+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 TYPE_INDEX_MAP = {
+    alias: ALIAS,
+    aliases: ALIASES,
+    microbuffer: MICRO_BUFFER,
+    references: REFERENCES,
+    reference: REFERENCE,
+    timestamp: TIMESTAMP,
+    boolean: BOOLEAN,
+    created: CREATED,
+    updated: UPDATED,
+    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,
+};
+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,
+    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,
+};
+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 = {};
+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,
+    len: 4,
+    __isPropDef: true,
+};
+export const EMPTY_MICRO_BUFFER = {
+    typeIndex: TYPE_INDEX_MAP['microbuffer'],
+    separate: true,
+    path: [''],
+    start: 0,
+    prop: 0,
+    len: 1,
+    __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,4 @@
+import { PropDef, PropDefEdge } from './types.js';
+export declare const propIsSigned: (prop: PropDef | PropDefEdge) => boolean;
+export declare const propIsNumerical: (prop: PropDef | PropDefEdge) => boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/def/utils.js

@@ -0,0 +1,23 @@
+import { INT16, INT32, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, } from './types.js';
+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;
+};
+//# sourceMappingURL=utils.js.map

package/dist/lang.d.ts

@@ -145,7 +145,7 @@ declare const langCodes: {
     readonly yo: 143;
     readonly zu: 144;
 };
-export declare const langCodesMap: Map<string, 0 | 2 | 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144>;
+export declare const langCodesMap: Map<string, 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144>;
 export declare const inverseLangMap: Map<any, any>;
 export type LangName = keyof typeof langCodes;
 export type LangCode = (typeof langCodes)[LangName];

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.3",
+  "version": "5.0.0-alpha.5",
   "license": "MIT",
-  "main": "dist/index.js",
   "files": [
     "dist",
     "README.md",
     "package.json",
     "!dist/**/*.map"
   ],
+  "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 +28,7 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
+    "@saulx/utils": "^5.0.0",
     "picocolors": "^1.1.0"
   }
 }