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

package/dist/def/addEdges.d.ts

@@ -0,0 +1,4 @@
+import { SchemaReference } from '../index.js';
+import { PropDef } from './types.js';
+export declare const addEdges: (prop: PropDef, refProp: SchemaReference) => void;
+//# sourceMappingURL=addEdges.d.ts.map

package/dist/def/addEdges.js

@@ -0,0 +1,51 @@
+import { getPropType } from '../index.js';
+import { SIZE_MAP, TYPE_INDEX_MAP, REFERENCES, REFERENCE, ENUM, } from './types.js';
+export 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;
+        }
+    }
+};
+//# sourceMappingURL=addEdges.js.map

package/dist/def/createEmptyDef.d.ts

@@ -0,0 +1,37 @@
+import { SchemaLocales, SchemaObject, StrictSchemaType } from '../types.js';
+export declare const createEmptyDef: (typeName: string, type: StrictSchemaType | SchemaObject, locales: Partial<SchemaLocales>) => {
+    cnt: number;
+    blockCapacity: number;
+    checksum: number;
+    type: string;
+    props: {};
+    reverseProps: {};
+    idUint8: Uint8Array;
+    id: number;
+    mainLen: number;
+    separate: any[];
+    tree: {};
+    total: number;
+    lastId: number;
+    locales: {};
+    main: {};
+    localeSize: number;
+    hasSeperateSort: boolean;
+    seperateSort: {
+        size: number;
+        props: any[];
+        buffer: Uint8Array;
+        bufferTmp: Uint8Array;
+    };
+    hasSeperateTextSort: boolean;
+    seperateTextSort: {
+        size: number;
+        props: any[];
+        buffer: Uint8Array;
+        noUndefined: Uint8Array;
+        bufferTmp: Uint8Array;
+        localeStringToIndex: Map<any, any>;
+        localeToIndex: Map<any, any>;
+    };
+};
+//# sourceMappingURL=createEmptyDef.d.ts.map

package/dist/def/createEmptyDef.js

@@ -0,0 +1,39 @@
+import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
+export const createEmptyDef = (typeName, type, locales) => {
+    return {
+        cnt: 0,
+        blockCapacity: 0,
+        checksum: hashObjectIgnoreKeyOrder(type),
+        type: typeName,
+        props: {},
+        reverseProps: {},
+        idUint8: new Uint8Array([0, 0]),
+        id: 0,
+        mainLen: 0,
+        separate: [],
+        tree: {},
+        total: 0,
+        lastId: 0,
+        locales: {},
+        main: {},
+        localeSize: 0,
+        hasSeperateSort: false,
+        seperateSort: {
+            size: 0,
+            props: [],
+            buffer: new Uint8Array([]),
+            bufferTmp: new Uint8Array([]),
+        },
+        hasSeperateTextSort: false,
+        seperateTextSort: {
+            size: 0, // prop len
+            props: [],
+            buffer: new Uint8Array([]),
+            noUndefined: new Uint8Array(new Array(Object.keys(locales).length).fill(0)),
+            bufferTmp: new Uint8Array([]),
+            localeStringToIndex: new Map(),
+            localeToIndex: new Map(),
+        },
+    };
+};
+//# sourceMappingURL=createEmptyDef.js.map

package/dist/def/getPropLen.d.ts

@@ -0,0 +1,3 @@
+import { SchemaProp } from '../types.js';
+export declare function getPropLen(schemaProp: SchemaProp): any;
+//# sourceMappingURL=getPropLen.d.ts.map

package/dist/def/getPropLen.js

@@ -0,0 +1,23 @@
+import { getPropType } from '../parse/utils.js';
+import { isPropType } from '../types.js';
+import { SIZE_MAP } from './types.js';
+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;
+}
+//# sourceMappingURL=getPropLen.js.map

package/dist/def/index.d.ts

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

package/dist/def/index.js

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

package/dist/def/makePacked.d.ts

@@ -0,0 +1,3 @@
+import { SchemaTypeDef, PropDef } from './types.js';
+export declare function makePacked(result: Partial<SchemaTypeDef>, typeName: string, vals: PropDef[], len: number): void;
+//# sourceMappingURL=makePacked.d.ts.map

package/dist/def/makePacked.js

@@ -0,0 +1,50 @@
+export 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);
+}
+//# sourceMappingURL=makePacked.js.map

package/dist/def/makeSeparateSort.d.ts

@@ -0,0 +1,3 @@
+import { SchemaTypeDef } from './types.js';
+export declare function makeSeparateSort(result: Partial<SchemaTypeDef>): void;
+//# sourceMappingURL=makeSeparateSort.d.ts.map

package/dist/def/makeSeparateSort.js

@@ -0,0 +1,27 @@
+import { STRING, ALIAS, CARDINALITY } from './types.js';
+export 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);
+}
+//# sourceMappingURL=makeSeparateSort.js.map

package/dist/def/makeSeparateTextSort.d.ts

@@ -0,0 +1,3 @@
+import { SchemaTypeDef } from './types.js';
+export declare function makeSeparateTextSort(result: Partial<SchemaTypeDef>): void;
+//# sourceMappingURL=makeSeparateTextSort.d.ts.map

package/dist/def/makeSeparateTextSort.js

@@ -0,0 +1,38 @@
+import { langCodesMap } from '../lang.js';
+import { TEXT } from './types.js';
+export 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;
+            }
+        }
+    }
+    const bufLen = (max + 1) * (result.localeSize + 1);
+    result.seperateTextSort.buffer = new Uint8Array(bufLen);
+    let index = 0;
+    for (const code in result.locales) {
+        const codeLang = langCodesMap.get(code);
+        result.seperateTextSort.localeStringToIndex.set(code, new Uint8Array([index + 1, codeLang]));
+        result.seperateTextSort.localeToIndex.set(codeLang, index + 1);
+        index++;
+    }
+    for (const f of result.separate) {
+        if (f.typeIndex === TEXT) {
+            const index = f.prop * (result.localeSize + 1);
+            result.seperateTextSort.buffer[index] = result.localeSize;
+            for (const [, locales] of result.seperateTextSort.localeStringToIndex) {
+                result.seperateTextSort.buffer[locales[0] + index] = locales[1];
+            }
+            result.seperateTextSort.props.push(f);
+            result.seperateTextSort.size += result.localeSize;
+        }
+    }
+    result.seperateTextSort.props.sort((a, b) => (a.prop > b.prop ? 1 : -1));
+    result.seperateTextSort.bufferTmp = new Uint8Array(bufLen);
+    result.seperateTextSort.bufferTmp.fill(0);
+    result.seperateTextSort.bufferTmp.set(result.seperateTextSort.buffer);
+}
+//# sourceMappingURL=makeSeparateTextSort.js.map

package/dist/def/readFromPacked.js

@@ -78,6 +78,9 @@ export const readFromPacked = (packed) => {
         },
         hasSeperateTextSort: false,
         seperateTextSort: {
+            localeToIndex: new Map(),
+            localeStringToIndex: new Map(),
+            noUndefined: new Uint8Array([]),
             size: 0,
             buffer: new Uint8Array([]),
             bufferTmp: new Uint8Array([]),
@@ -90,7 +93,7 @@ export const readFromPacked = (packed) => {
     let s = 0;
     for (const p of mainProps) {
         const len = REVERSE_SIZE_MAP[p.typeIndex];
-        result.props[p.path] = {
+        const prop = {
             prop: p.prop,
             separate: false,
             __isPropDef: true,
@@ -99,10 +102,12 @@ export const readFromPacked = (packed) => {
             path: p.path.split('.'),
             len,
         };
+        result.props[p.path] = prop;
+        result.main[prop.start] = prop;
         s += len;
     }
     for (const p of props) {
-        result.props[p.path] = {
+        const prop = {
             prop: p.prop,
             separate: true,
             __isPropDef: true,
@@ -112,6 +117,8 @@ export const readFromPacked = (packed) => {
             len: 0,
             compression: 1,
         };
+        result.props[p.path] = prop;
+        result.reverseProps[prop.prop] = prop;
     }
     // make this into a typeDef
     //   return {

package/dist/def/selvaBuffer.d.ts

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

package/dist/def/selvaBuffer.js

@@ -1,5 +1,5 @@
 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 = [];
+const selvaTypeMap = new Uint8Array(32); // 1.2x faster than JS array
 selvaTypeMap[NULL] = 0;
 selvaTypeMap[TIMESTAMP] = 4;
 selvaTypeMap[CREATED] = 1;
@@ -28,8 +28,9 @@ selvaTypeMap[VECTOR] = 17;
 selvaTypeMap[JSON] = 11;
 const EDGE_FIELD_CONSTRAINT_FLAG_DEPENDENT = 0x01;
 function blockCapacity(blockCapacity) {
-    const buf = Buffer.allocUnsafe(4);
-    buf.writeInt32LE(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) {
@@ -42,20 +43,22 @@ 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);
+        const buf = new Uint8Array(3);
+        const view = new DataView(buf.buffer);
         buf[0] = selvaType;
-        buf.writeUint16LE(prop.len, 1);
-        return [...buf.values()];
+        view.setUint16(1, prop.len, true);
+        return [...buf];
     }
     else if (type === REFERENCE || type === REFERENCES) {
-        const buf = Buffer.allocUnsafe(9);
+        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
-        buf.writeUInt16LE(dstType.id, 2); // dst_node_type
-        buf.writeUint32LE(0, 5); // schema_len
+        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;
@@ -66,10 +69,10 @@ const propDefBuffer = (schema, prop, isEdge) => {
                     .map((prop) => propDefBuffer(schema, prop, true))
                     .flat(1);
                 eschema.unshift(0, 0, 0, 0, sepPropCount(props), 0);
-                buf.writeUint32LE(eschema.length, 5);
+                view.setUint32(5, eschema.length, true);
             }
         }
-        return [...buf.values(), ...eschema];
+        return [...buf, ...eschema];
     }
     else if (type === STRING ||
         type === BINARY ||
@@ -81,12 +84,8 @@ const propDefBuffer = (schema, prop, isEdge) => {
         return [selvaType];
     }
 };
-// todo rewrite
+// 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 = [];
@@ -100,8 +99,8 @@ export function schemaToSelvaBuffer(schema) {
             }
         }
         rest.sort((a, b) => a.prop - b.prop);
-        return Buffer.from([
-            ...blockCapacity(t.blockCapacity).values(),
+        return Uint8Array.from([
+            ...blockCapacity(t.blockCapacity),
             1 + sepPropCount(props),
             1 + refFields,
             ...propDefBuffer(schema, {
@@ -109,7 +108,7 @@ export function schemaToSelvaBuffer(schema) {
                 len: t.mainLen === 0 ? 1 : t.mainLen,
             }),
             ...rest.map((f) => propDefBuffer(schema, f)).flat(1),
-        ]);
+        ]).buffer;
     });
 }
 //# sourceMappingURL=selvaBuffer.js.map

package/dist/def/typeDef.js

@@ -1,174 +1,15 @@
 import { isPropType, getPropType, } from '../index.js';
 import { setByPath } from '@saulx/utils';
+import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, } from './types.js';
+import { makePacked } from './makePacked.js';
+import { makeSeparateTextSort } from './makeSeparateTextSort.js';
+import { makeSeparateSort } from './makeSeparateSort.js';
+import { getPropLen } from './getPropLen.js';
+import { isSeparate } from './utils.js';
+import { addEdges } from './addEdges.js';
+import { createEmptyDef } from './createEmptyDef.js';
 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) {
@@ -199,35 +40,7 @@ export const updateTypeDefs = (schema, schemaTypesParsed, schemaTypesParsedById)
         }
     }
 };
-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) => {
+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;
@@ -256,7 +69,8 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = {
                 isPropType('alias', schemaProp) ||
                 isPropType('cardinality', schemaProp)) {
                 if (typeof schemaProp === 'object') {
-                    if (!(schemaProp.maxBytes < 61) || !('max' in schemaProp && schemaProp.max < 31)) {
+                    if (!(schemaProp.maxBytes < 61) ||
+                        !('max' in schemaProp && schemaProp.max < 31)) {
                         separateSortProps++;
                     }
                 }

package/dist/def/types.d.ts

@@ -1,4 +1,4 @@
-import type { SchemaLocales } from '../index.js';
+import type { LangCode, SchemaLocales } from '../index.js';
 export declare const NULL = 0;
 export declare const TIMESTAMP = 1;
 export declare const CREATED = 2;
@@ -126,7 +126,11 @@ export type SchemaTypeDef = {
     hasSeperateSort: boolean;
     seperateSort: SchemaSortUndefinedHandler;
     hasSeperateTextSort: boolean;
-    seperateTextSort: SchemaSortUndefinedHandler;
+    seperateTextSort: SchemaSortUndefinedHandler & {
+        noUndefined: Uint8Array;
+        localeStringToIndex: Map<string, Uint8Array>;
+        localeToIndex: Map<LangCode, number>;
+    };
     createTs?: PropDef[];
     updateTs?: PropDef[];
     locales: Partial<SchemaLocales>;

package/dist/def/utils.d.ts

@@ -1,4 +1,7 @@
 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;
 //# sourceMappingURL=utils.d.ts.map

package/dist/def/utils.js

@@ -1,4 +1,9 @@
-import { INT16, INT32, INT8, UINT16, UINT32, UINT8, NUMBER, TIMESTAMP, } from './types.js';
+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';
+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) {
@@ -20,4 +25,23 @@ export const propIsNumerical = (prop) => {
     }
     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;
+}
 //# 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 | 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 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 inverseLangMap: Map<any, any>;
 export type LangName = keyof typeof langCodes;
 export type LangCode = (typeof langCodes)[LangName];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.5",
+  "version": "5.0.0-alpha.6",
   "license": "MIT",
   "files": [
     "dist",