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

package/dist/def/addEdges.js

@@ -1,33 +1,35 @@
 import { getPropType } from '../index.js';
-import { SIZE_MAP, TYPE_INDEX_MAP, REFERENCES, REFERENCE, ENUM, } from './types.js';
+import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, ENUM, } from './types.js';
+import { getPropLen, isSeparate } from './utils.js';
 export const addEdges = (prop, refProp) => {
-    let edgesCnt = 0;
     for (const key in refProp) {
         if (key[0] === '$') {
             if (!prop.edges) {
+                prop.edgeMainLen = 0;
                 prop.edges = {};
-                prop.reverseEdges = {};
-                prop.edgesTotalLen = 0;
+                prop.reverseSeperateEdges = {};
+                prop.reverseMainEdges = {};
+                prop.edgesSeperateCnt = 0;
+            }
+            const edgeProp = refProp[key];
+            const edgeType = getPropType(edgeProp);
+            const len = getPropLen(edgeProp);
+            const separate = isSeparate(edgeProp, len);
+            if (separate) {
+                prop.edgesSeperateCnt++;
             }
-            edgesCnt++;
-            const edgeType = getPropType(refProp[key]);
             const edge = {
                 __isPropDef: true,
                 __isEdge: true,
-                prop: edgesCnt,
+                prop: separate ? prop.edgesSeperateCnt : 0,
                 name: key,
                 typeIndex: TYPE_INDEX_MAP[edgeType],
-                len: SIZE_MAP[edgeType],
-                separate: true,
+                len,
+                separate,
                 path: [...prop.path, key],
+                start: prop.edgeMainLen,
             };
-            if (edge.len == 0) {
-                prop.edgesTotalLen = 0;
-            }
-            else {
-                // [field] [size] [data]
-                prop.edgesTotalLen += 1 + 2 + edge.len; // field len
-            }
+            prop.edgeMainLen += edge.len;
             if (edge.typeIndex === ENUM) {
                 edge.enum = Array.isArray(refProp[key])
                     ? refProp[key]
@@ -44,7 +46,12 @@ export const addEdges = (prop, refProp) => {
                 edge.inverseTypeName = refProp[key].ref;
             }
             prop.edges[key] = edge;
-            prop.reverseEdges[edge.prop] = edge;
+            if (separate) {
+                prop.reverseSeperateEdges[edge.prop] = edge;
+            }
+            else {
+                prop.reverseMainEdges[edge.start] = edge;
+            }
         }
     }
 };

package/dist/def/createEmptyDef.d.ts

@@ -8,6 +8,7 @@ export declare const createEmptyDef: (typeName: string, type: StrictSchemaType |
     reverseProps: {};
     idUint8: Uint8Array;
     id: number;
+    mainEmpty: Uint8Array;
     mainLen: number;
     separate: any[];
     tree: {};

package/dist/def/createEmptyDef.js

@@ -8,7 +8,9 @@ export const createEmptyDef = (typeName, type, locales) => {
         props: {},
         reverseProps: {},
         idUint8: new Uint8Array([0, 0]),
+        // empty main buffer
         id: 0,
+        mainEmpty: new Uint8Array(0),
         mainLen: 0,
         separate: [],
         tree: {},

package/dist/def/fillEmptyMain.d.ts

@@ -0,0 +1,5 @@
+import { PropDef } from './types.js';
+export declare const ENCODER: TextEncoder;
+export declare const fillEmptyMain: (vals: PropDef[], mainLen: number) => Uint8Array;
+export declare const isZeroes: (buf: Uint8Array) => boolean;
+//# sourceMappingURL=fillEmptyMain.d.ts.map

package/dist/def/fillEmptyMain.js

@@ -0,0 +1,56 @@
+import { BINARY, BOOLEAN, CREATED, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, UPDATED, } from './types.js';
+// Lets add validation of values in here - need to validate DEFAULT!
+export const ENCODER = new TextEncoder();
+export const fillEmptyMain = (vals, mainLen) => {
+    const mainEmpty = new Uint8Array(mainLen);
+    for (const f of vals) {
+        if (f.separate) {
+            continue;
+        }
+        const t = f.typeIndex;
+        const s = f.start;
+        let val = f.default;
+        if (t === BOOLEAN || t === INT8 || t === UINT8 || t === ENUM) {
+            mainEmpty[s] = val === true ? 1 : 0;
+        }
+        else if (t === UINT32 || t === INT32) {
+            mainEmpty[s] = val;
+            mainEmpty[s + 1] = val >>>= 8;
+            mainEmpty[s + 2] = val >>>= 8;
+            mainEmpty[s + 3] = val >>>= 8;
+        }
+        else if (t === UINT16 || t === INT16) {
+            mainEmpty[s] = val;
+            mainEmpty[s + 1] = val >>>= 8;
+        }
+        else if (t === NUMBER ||
+            t === TIMESTAMP ||
+            t === CREATED ||
+            t === UPDATED) {
+            const view = new DataView(mainEmpty.buffer, s, 8);
+            view.setFloat64(0, val, true);
+        }
+        else if (t === STRING) {
+            val = ENCODER.encode(val);
+            mainEmpty[s] = val.byteLength;
+            mainEmpty.set(val, s + 1);
+        }
+        else if (t === BINARY) {
+            if (val !== undefined) {
+                mainEmpty.set(val, s);
+            }
+        }
+    }
+    return mainEmpty;
+};
+export const isZeroes = (buf) => {
+    let i = 0;
+    while (i < buf.byteLength) {
+        if (buf[i] !== 0) {
+            return false;
+        }
+        i++;
+    }
+    return true;
+};
+//# sourceMappingURL=fillEmptyMain.js.map

package/dist/def/readFromPacked.js

@@ -1,4 +1,4 @@
-import { REVERSE_SIZE_MAP } from './types.js';
+import { DEFAULT_MAP, REVERSE_SIZE_MAP, } from './types.js';
 export const readFromPacked = (packed) => {
     const size = (packed[0] | (packed[1] << 8)) >>> 0;
     const props = [];
@@ -86,6 +86,8 @@ export const readFromPacked = (packed) => {
             bufferTmp: new Uint8Array([]),
             props: [],
         },
+        mainEmpty: new Uint8Array([]),
+        mainEmptyAllZeroes: true,
         // need this...
         locales: {},
         localeSize: 0,
@@ -98,6 +100,7 @@ export const readFromPacked = (packed) => {
             separate: false,
             __isPropDef: true,
             start: s,
+            default: DEFAULT_MAP[p.typeIndex], // tmp
             typeIndex: p.typeIndex,
             path: p.path.split('.'),
             len,
@@ -113,6 +116,7 @@ export const readFromPacked = (packed) => {
             __isPropDef: true,
             start: 0,
             typeIndex: p.typeIndex,
+            default: DEFAULT_MAP[p.typeIndex], // tmp
             path: p.path.split('.'),
             len: 0,
             compression: 1,

package/dist/def/selvaBuffer.js

@@ -1,31 +1,18 @@
-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';
+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[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;
+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);
@@ -64,12 +51,26 @@ const propDefBuffer = (schema, prop, isEdge) => {
             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);
-                view.setUint32(5, eschema.length, true);
+                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];

package/dist/def/typeDef.js

@@ -1,6 +1,6 @@
 import { isPropType, getPropType, } from '../index.js';
 import { setByPath } from '@saulx/utils';
-import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, } from './types.js';
+import { TYPE_INDEX_MAP, REFERENCES, REFERENCE, DEFAULT_MAP, } from './types.js';
 import { makePacked } from './makePacked.js';
 import { makeSeparateTextSort } from './makeSeparateTextSort.js';
 import { makeSeparateSort } from './makeSeparateSort.js';
@@ -9,6 +9,7 @@ import { isSeparate } from './utils.js';
 import { addEdges } from './addEdges.js';
 import { createEmptyDef } from './createEmptyDef.js';
 import { hashObjectIgnoreKeyOrder } from '@saulx/hash';
+import { fillEmptyMain, isZeroes } from './fillEmptyMain.js';
 export const DEFAULT_BLOCK_CAPACITY = 100_000;
 export const updateTypeDefs = (schema, schemaTypesParsed, schemaTypesParsedById) => {
     for (const field in schemaTypesParsed) {
@@ -57,6 +58,7 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
     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);
@@ -89,6 +91,7 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 path: propPath,
                 start: 0,
                 len,
+                default: schemaProp.default ?? DEFAULT_MAP[TYPE_INDEX_MAP[propType]],
                 prop: isseparate ? ++result.cnt : 0,
             };
             if (isPropType('enum', schemaProp)) {
@@ -138,6 +141,7 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
         }
     }
     if (top) {
+        // Put top level together
         const vals = Object.values(result.props);
         vals.sort((a, b) => {
             if (b.separate &&
@@ -168,6 +172,8 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 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);

package/dist/def/types.d.ts

@@ -68,18 +68,24 @@ export type PropDef = {
     inverseTypeId?: number;
     inversePropNumber?: number;
     enum?: any[];
+    dependent?: boolean;
+    default: any;
+    edgeMainLen?: 0;
     reverseEnum?: {
         [key: string]: number;
     };
-    edgesTotalLen?: number;
+    edgesSeperateCnt?: number;
     edges?: {
         [key: string]: PropDefEdge;
     };
-    reverseEdges?: {
+    reverseSeperateEdges?: {
         [prop: string]: PropDefEdge;
     };
+    reverseMainEdges?: {
+        [start: string]: PropDefEdge;
+    };
+    edgeMainEmpty?: Uint8Array;
     __isEdge?: boolean;
-    dependent?: boolean;
 };
 export type PropDefEdge = Partial<PropDef> & {
     __isPropDef: true;
@@ -90,6 +96,13 @@ export type PropDefEdge = Partial<PropDef> & {
     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;
 };
@@ -122,6 +135,8 @@ export type SchemaTypeDef = {
     main: {
         [start: string]: PropDef;
     };
+    mainEmpty: Uint8Array;
+    mainEmptyAllZeroes: boolean;
     tree: SchemaPropTree;
     hasSeperateSort: boolean;
     seperateSort: SchemaSortUndefinedHandler;
@@ -137,7 +152,8 @@ export type SchemaTypeDef = {
     localeSize: number;
 };
 export declare const SIZE_MAP: Record<InternalSchemaProp, number>;
-export declare let REVERSE_SIZE_MAP: Record<TypeIndex, number>;
+export declare const DEFAULT_MAP: Record<TypeIndex, any>;
+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;

package/dist/def/types.js

@@ -83,9 +83,34 @@ 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 = {};
+// TODO update defaults
+export const DEFAULT_MAP = {
+    [TYPE_INDEX_MAP.alias]: '',
+    [TYPE_INDEX_MAP.binary]: undefined,
+    [TYPE_INDEX_MAP.boolean]: false,
+    [TYPE_INDEX_MAP.cardinality]: 0,
+    [TYPE_INDEX_MAP.created]: 0,
+    [TYPE_INDEX_MAP.updated]: 0,
+    [TYPE_INDEX_MAP.number]: 0,
+    [TYPE_INDEX_MAP.timestamp]: 0,
+    [TYPE_INDEX_MAP.enum]: 0,
+    [TYPE_INDEX_MAP.id]: 0,
+    [TYPE_INDEX_MAP.int16]: 0,
+    [TYPE_INDEX_MAP.int32]: 0,
+    [TYPE_INDEX_MAP.int8]: 0,
+    [TYPE_INDEX_MAP.uint8]: 0,
+    [TYPE_INDEX_MAP.uint16]: 0,
+    [TYPE_INDEX_MAP.uint32]: 0,
+    [TYPE_INDEX_MAP.json]: undefined,
+    [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.vector]: undefined, // maybe not can set a vec with 0
+};
+export const REVERSE_SIZE_MAP = {};
 for (const k in SIZE_MAP) {
     REVERSE_SIZE_MAP[TYPE_INDEX_MAP[k]] = SIZE_MAP[k];
 }
@@ -96,6 +121,7 @@ export const ID_FIELD_DEF = {
     path: ['id'],
     start: 0,
     prop: 255,
+    default: 0,
     len: 4,
     __isPropDef: true,
 };
@@ -104,6 +130,7 @@ export const EMPTY_MICRO_BUFFER = {
     separate: true,
     path: [''],
     start: 0,
+    default: undefined,
     prop: 0,
     len: 1,
     __isPropDef: true,

package/dist/parse/index.d.ts

@@ -12,7 +12,7 @@ export declare class SchemaParser {
     parseTypes(): void;
     parseProps(props: any, schemaType?: SchemaType): void;
     parseLocales(): void;
-    parse(): void;
+    parse(): StrictSchema;
 }
 export declare const print: (schema: Schema, path: string[]) => string;
 export declare const parse: (schema: Schema) => {

package/dist/parse/index.js

@@ -3,10 +3,11 @@ import { getPropType } from './utils.js';
 import propParsers from './props.js';
 import pc from 'picocolors';
 import { expectBoolean, expectObject } from './assert.js';
+import { deepCopy } from '@saulx/utils';
 export { getPropType };
 export class SchemaParser {
     constructor(schema) {
-        this.schema = schema;
+        this.schema = deepCopy(schema);
     }
     isItems;
     inQuery;
@@ -97,6 +98,7 @@ export class SchemaParser {
                 throw Error(UNKNOWN_PROP);
             }
         }
+        return this.schema;
     }
 }
 export const print = (schema, path) => {
@@ -120,9 +122,7 @@ export const print = (schema, path) => {
 export const parse = (schema) => {
     const parser = new SchemaParser(schema);
     try {
-        parser.parse();
-        // @ts-ignore
-        return { schema };
+        return { schema: parser.parse() };
     }
     catch (e) {
         const cause = parser.path.slice(0, Math.min(4, parser.lvl) + 1);

package/dist/parse/props.js

@@ -270,6 +270,7 @@ p.text = propParser({
         throw Error(TEXT_REQUIRES_LOCALES);
     },
 }, {
+    format: binaryOpts.format,
     default(val, prop) {
         console.warn('MAKE DEFAULT VALUE FOR TEXT');
     },

package/dist/types.d.ts

@@ -40,6 +40,7 @@ export type SchemaReferencesOneWay = Prop<{
 export type SchemaText = Prop<{
     type: 'text';
     default?: Record<string, string>;
+    format?: StringFormat;
 }>;
 type NumberType = 'number' | 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32';
 export type SchemaNumber = Prop<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.6",
+  "version": "5.0.0-alpha.8",
   "license": "MIT",
   "files": [
     "dist",
@@ -8,6 +8,7 @@
     "package.json",
     "!dist/**/*.map"
   ],
+  "main": "./dist/index.js",
   "exports": {
     "./def": "./dist/def/index.js",
     ".": "./dist/index.js"
@@ -28,7 +29,7 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@saulx/utils": "^5.0.0",
+    "@saulx/utils": "^6.1.1",
     "picocolors": "^1.1.0"
   }
-}
+}