@based/schema 5.0.0-alpha.10 → 5.0.0-alpha.12

package/dist/def/createEmptyDef.d.ts

@@ -16,6 +16,8 @@ export declare const createEmptyDef: (typeName: string, type: StrictSchemaType |
     lastId: number;
     locales: {};
     main: {};
+    separateSortProps: number;
+    separateSortText: number;
     localeSize: number;
     hasSeperateSort: boolean;
     seperateSort: {

package/dist/def/createEmptyDef.js

@@ -18,6 +18,8 @@ export const createEmptyDef = (typeName, type, locales) => {
         lastId: 0,
         locales: {},
         main: {},
+        separateSortProps: 0,
+        separateSortText: 0,
         localeSize: 0,
         hasSeperateSort: false,
         seperateSort: {

package/dist/def/defaultMap.js

@@ -15,13 +15,13 @@ export const DEFAULT_MAP = {
     [TYPE_INDEX_MAP.uint8]: 0,
     [TYPE_INDEX_MAP.uint16]: 0,
     [TYPE_INDEX_MAP.uint32]: 0,
-    [TYPE_INDEX_MAP.json]: undefined,
+    [TYPE_INDEX_MAP.json]: null,
     [TYPE_INDEX_MAP.microbuffer]: undefined,
     [TYPE_INDEX_MAP.reference]: undefined,
     [TYPE_INDEX_MAP.references]: [],
     [TYPE_INDEX_MAP.string]: '',
     [TYPE_INDEX_MAP.aliases]: [],
-    [TYPE_INDEX_MAP.text]: '',
+    [TYPE_INDEX_MAP.text]: {},
     [TYPE_INDEX_MAP.vector]: undefined, // maybe not can set a vec with 0
 };
 //# sourceMappingURL=defaultMap.js.map

package/dist/def/index.d.ts

@@ -2,7 +2,6 @@ export * from './types.js';
 export * from './typeDef.js';
 export * from './utils.js';
 export * from './selvaBuffer.js';
-export * from './readFromPacked.js';
 export * from './createEmptyDef.js';
 export * from './defaultMap.js';
 export * from './validation.js';

package/dist/def/index.js

@@ -3,7 +3,6 @@ export * from './types.js';
 export * from './typeDef.js';
 export * from './utils.js';
 export * from './selvaBuffer.js';
-export * from './readFromPacked.js';
 export * from './createEmptyDef.js';
 export * from './defaultMap.js';
 export * from './validation.js';

package/dist/def/typeDef.js

@@ -2,7 +2,6 @@ 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';
@@ -58,8 +57,6 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
     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];
@@ -76,15 +73,15 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 if (typeof schemaProp === 'object') {
                     if (!(schemaProp.maxBytes < 61) ||
                         !('max' in schemaProp && schemaProp.max < 31)) {
-                        separateSortProps++;
+                        result.separateSortProps++;
                     }
                 }
                 else {
-                    separateSortProps++;
+                    result.separateSortProps++;
                 }
             }
             else if (isPropType('text', schemaProp)) {
-                separateSortText++;
+                result.separateSortText++;
             }
             const isseparate = isSeparate(schemaProp, len);
             const typeIndex = TYPE_INDEX_MAP[propType];
@@ -193,11 +190,10 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
         }
         result.mainEmpty = fillEmptyMain(vals, result.mainLen);
         result.mainEmptyAllZeroes = isZeroes(result.mainEmpty);
-        makePacked(result, typeName, vals, len);
-        if (separateSortText > 0) {
+        if (result.separateSortText > 0) {
             makeSeparateTextSort(result);
         }
-        if (separateSortProps > 0) {
+        if (result.separateSortProps > 0) {
             makeSeparateSort(result);
         }
         for (const p in result.props) {

package/dist/def/types.d.ts

@@ -25,6 +25,7 @@ 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;
@@ -48,6 +49,7 @@ export declare const TYPE_INDEX_MAP: {
     vector: number;
     cardinality: number;
     json: number;
+    object: number;
 };
 export type InternalSchemaProp = keyof typeof TYPE_INDEX_MAP;
 export type TypeIndex = (typeof TYPE_INDEX_MAP)[InternalSchemaProp];
@@ -123,7 +125,6 @@ export type SchemaTypeDef = {
     mainLen: number;
     buf: Uint8Array;
     propNames: Uint8Array;
-    packed: Uint8Array;
     props: {
         [path: string]: PropDef;
     };
@@ -139,6 +140,8 @@ export type SchemaTypeDef = {
     mainEmpty: Uint8Array;
     mainEmptyAllZeroes: boolean;
     tree: SchemaPropTree;
+    separateSortProps: number;
+    separateSortText: number;
     hasSeperateSort: boolean;
     seperateSort: SchemaSortUndefinedHandler;
     hasSeperateTextSort: boolean;

package/dist/def/types.js

@@ -24,6 +24,7 @@ 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,
@@ -47,6 +48,7 @@ export const TYPE_INDEX_MAP = {
     vector: VECTOR,
     cardinality: CARDINALITY,
     json: JSON,
+    object: OBJECT,
 };
 export const SIZE_MAP = {
     timestamp: 8, // 64bit
@@ -72,6 +74,7 @@ export const SIZE_MAP = {
     binary: 0,
     vector: 0, // separate
     json: 0,
+    object: 0,
 };
 const reverseMap = {};
 for (const k in TYPE_INDEX_MAP) {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export * from './types.js';
 export * from './parse/index.js';
 export * from './lang.js';
-export * from './mermaid.js';
 export * from './def/validation.js';
+export * from './serialize.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,6 @@
 export * from './types.js';
 export * from './parse/index.js';
 export * from './lang.js';
-export * from './mermaid.js';
 export * from './def/validation.js';
+export * from './serialize.js';
 //# sourceMappingURL=index.js.map

package/dist/parse/assert.js

@@ -1,4 +1,3 @@
-import { isFloat32Array } from 'util/types';
 import { EXPECTED_ARR, EXPECTED_BOOL, EXPECTED_FN, EXPECTED_NUM, EXPECTED_OBJ, EXPECTED_STR, } from './errors.js';
 export const expectObject = (obj, msg) => {
     if (typeof obj !== 'object' || obj === null) {
@@ -6,7 +5,7 @@ export const expectObject = (obj, msg) => {
     }
 };
 export const expectFloat32Array = (arr) => {
-    if (!isFloat32Array(arr)) {
+    if (!(arr instanceof Float32Array)) {
         throw Error(EXPECTED_ARR);
     }
 };

package/dist/parse/props.js

@@ -348,7 +348,7 @@ p.reference = propParser({
             throw Error(MISSING_TYPE);
         }
     },
-    prop(propKey, prop, { schema, type, inQuery, path }) {
+    prop(propKey, prop, { schema, type, inQuery, path, lvl }) {
         const propAllowed = type && !inQuery;
         if (propAllowed) {
             expectString(propKey);
@@ -366,7 +366,7 @@ p.reference = propParser({
             if (create) {
                 const ref = path[1];
                 let prop = '';
-                for (let i = 3; i < path.length - 1; i += 2) {
+                for (let i = 3; i < lvl; i += 2) {
                     prop += prop ? `.${path[i]}` : path[i];
                 }
                 targetProp.readOnly = true;

package/dist/serialize.d.ts

@@ -0,0 +1,5 @@
+import { StrictSchema } from './types.js';
+export declare const serialize: (schema: any, noCompression?: boolean) => Uint8Array;
+export declare const deSerializeInner: (buf: Uint8Array, obj: any, start: number) => number;
+export declare const deSerialize: (buf: Uint8Array) => StrictSchema;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/serialize.js

@@ -0,0 +1,142 @@
+import * as deflate from 'fflate';
+import { REVERSE_TYPE_INDEX_MAP, TYPE_INDEX_MAP } from './def/types.js';
+const ENCODER = new TextEncoder();
+let schemaBuffer;
+// 3 level
+// 0 for queries (min)
+// 1 for modify
+// 2 fulls schema
+const walk = (obj, prev, prev2, fromObject, schemaBuffer) => {
+    let start = schemaBuffer.len;
+    // HANDLE ENUM
+    const isSchemaProp = 'type' in obj && (prev2?.type === 'object' || fromObject === false);
+    if (isSchemaProp) {
+        schemaBuffer.buf[schemaBuffer.len++] = 254;
+        const typeIndex = TYPE_INDEX_MAP[obj.type];
+        schemaBuffer.buf[schemaBuffer.len++] = typeIndex;
+    }
+    else {
+        schemaBuffer.buf[schemaBuffer.len++] = 255;
+    }
+    let sizeIndex = schemaBuffer.len;
+    schemaBuffer.len += 2;
+    for (const key in obj) {
+        if (key === 'type' && isSchemaProp) {
+            continue;
+        }
+        else {
+            let address = schemaBuffer.dictMap[key];
+            // if len == 1 never from address
+            if (!address) {
+                address = schemaBuffer.len;
+                schemaBuffer.len += 1;
+                const r = ENCODER.encodeInto(key, schemaBuffer.buf.subarray(schemaBuffer.len));
+                schemaBuffer.buf[address] = r.written;
+                schemaBuffer.len += r.written;
+                schemaBuffer.dictMap[key] = address;
+            }
+            else {
+                schemaBuffer.buf[schemaBuffer.len] = 0;
+                schemaBuffer.len += 1;
+                schemaBuffer.buf[schemaBuffer.len] = address;
+                schemaBuffer.buf[schemaBuffer.len + 1] = address >>> 8;
+                schemaBuffer.len += 2;
+            }
+            const val = obj[key];
+            const type = typeof val;
+            // typed Array
+            if (Array.isArray(val)) {
+                // derp
+            }
+            else if (type === 'function') {
+                // derp
+            }
+            else if (type === 'object') {
+                // fromObject
+                if (val === null) {
+                }
+                else {
+                    if (!fromObject && key === 'props' && obj.type === 'object') {
+                        walk(val, obj, prev, true, schemaBuffer);
+                    }
+                    else {
+                        walk(val, obj, prev, fromObject, schemaBuffer);
+                    }
+                }
+            }
+            else if (type === 'string') {
+                // derp
+            }
+            else if (type === 'number') {
+                // do stuff
+            }
+        }
+    }
+    const size = schemaBuffer.len - start;
+    schemaBuffer.buf[sizeIndex] = size;
+    schemaBuffer.buf[sizeIndex + 1] = size >>> 8;
+};
+export const serialize = (schema, 
+// schema: StrictSchema,
+noCompression = false) => {
+    if (!schemaBuffer) {
+        // 1mb buffer add check if its large enough else increase
+        schemaBuffer = {
+            buf: new Uint8Array(1e6),
+            len: 0,
+            dictMap: {},
+        };
+    }
+    schemaBuffer.dictMap = {};
+    schemaBuffer.len = 0;
+    const isDeflate = noCompression ? 0 : 1;
+    walk(schema, undefined, undefined, false, schemaBuffer);
+    const packed = new Uint8Array(schemaBuffer.buf.subarray(0, schemaBuffer.len));
+    if (isDeflate) {
+        return deflate.deflateSync(packed);
+    }
+    else {
+        return packed;
+    }
+};
+const decoder = new TextDecoder();
+export const deSerializeInner = (buf, obj, start) => {
+    let i = start;
+    const isSchemaProp = buf[i] === 254;
+    i += 1;
+    if (isSchemaProp) {
+        const type = buf[i];
+        const parsedType = REVERSE_TYPE_INDEX_MAP[type];
+        obj.type = parsedType;
+        i += 1;
+    }
+    const size = buf[i] | ((buf[i + 1] << 8) >>> 0);
+    i += 2;
+    const end = size + start;
+    while (i < end) {
+        let keySize = buf[i];
+        i += 1;
+        let key;
+        if (keySize === 0) {
+            const dictAddress = buf[i] | ((buf[i + 1] << 8) >>> 0);
+            i += 2;
+            keySize = buf[dictAddress];
+            key = decoder.decode(buf.subarray(dictAddress + 1, keySize + dictAddress + 1));
+        }
+        else {
+            key = decoder.decode(buf.subarray(i, keySize + i));
+            i += keySize;
+        }
+        const nest = (obj[key] = {});
+        const fieldSize = deSerializeInner(buf, nest, i);
+        i += fieldSize;
+    }
+    return i - start;
+};
+export const deSerialize = (buf) => {
+    // if first byte is deflate
+    const schema = {};
+    deSerializeInner(buf, schema, 0);
+    return schema;
+};
+//# sourceMappingURL=serialize.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.10",
+  "version": "5.0.0-alpha.12",
   "license": "MIT",
   "files": [
     "dist",
@@ -29,7 +29,8 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@saulx/utils": "^6.4.0",
+    "fflate": "0.8.1",
+    "@saulx/utils": "^6.5.0",
     "picocolors": "^1.1.0"
   }
 }