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

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/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];

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

@@ -3,4 +3,5 @@ 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

@@ -3,4 +3,5 @@ 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/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,139 @@
+import * as deflate from 'fflate';
+import { REVERSE_TYPE_INDEX_MAP, TYPE_INDEX_MAP } from './def/types.js';
+const hasNative = '__basedDb__native__' in global;
+const ENCODER = new TextEncoder();
+let schemaBuffer;
+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.11",
   "license": "MIT",
   "files": [
     "dist",
@@ -29,6 +29,7 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
+    "fflate": "0.8.1",
     "@saulx/utils": "^6.4.0",
     "picocolors": "^1.1.0"
   }