@based/schema 5.0.0-alpha.2 → 5.0.0-alpha.21

package/dist/def/types.js

@@ -0,0 +1,138 @@
+// 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 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 OBJECT = 29;
+export const COLVEC = 30;
+export const TYPE_INDEX_MAP = {
+    alias: ALIAS,
+    aliases: ALIASES,
+    microbuffer: MICRO_BUFFER,
+    references: REFERENCES,
+    reference: REFERENCE,
+    timestamp: TIMESTAMP,
+    boolean: BOOLEAN,
+    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,
+    object: OBJECT,
+    colvec: COLVEC,
+};
+const numberTypeValues = [
+    NUMBER,
+    UINT16,
+    UINT32,
+    INT16,
+    INT32,
+    UINT8,
+    INT8,
+    CARDINALITY,
+];
+export function isNumberType(type) {
+    return numberTypeValues.includes(type);
+}
+export const BLOCK_CAPACITY_MIN = 1025;
+export const BLOCK_CAPACITY_MAX = 2147483647;
+export const BLOCK_CAPACITY_DEFAULT = 100_000;
+export const SIZE_MAP = {
+    timestamp: 8, // 64bit
+    // 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,
+    object: 0,
+    colvec: 0, // separate
+};
+const reverseMap = {};
+for (const k in TYPE_INDEX_MAP) {
+    reverseMap[TYPE_INDEX_MAP[k]] = k;
+}
+export const 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,
+    default: 0,
+    len: 4,
+    validation: () => true,
+    __isPropDef: true,
+};
+export const EMPTY_MICRO_BUFFER = {
+    typeIndex: TYPE_INDEX_MAP['microbuffer'],
+    separate: true,
+    path: [''],
+    start: 0,
+    default: undefined,
+    prop: 0,
+    len: 1,
+    validation: () => true,
+    __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,8 @@
+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;
+export declare const parseMinMaxStep: (val: any) => string | number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/def/utils.js

@@ -0,0 +1,62 @@
+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';
+import { convertToTimestamp } from '@saulx/utils';
+export function isSeparate(schemaProp, len) {
+    return len === 0 || isPropType('vector', schemaProp) || isPropType('colvec', schemaProp);
+}
+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;
+};
+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;
+    }
+    else if (isPropType('colvec', schemaProp)) {
+        len = schemaProp.size;
+    }
+    return len;
+}
+export const parseMinMaxStep = (val) => {
+    if (typeof val === 'number') {
+        return val;
+    }
+    if (typeof val === 'string') {
+        if (!val.includes('now')) {
+            return convertToTimestamp(val);
+        }
+        return val;
+    }
+};
+//# sourceMappingURL=utils.js.map

package/dist/def/validation.d.ts

@@ -0,0 +1,7 @@
+import { TypeIndex, PropDef, PropDefEdge } from './types.js';
+export type Validation = (payload: any, prop: PropDef | PropDefEdge) => boolean;
+export declare const VALIDATION_MAP: Record<TypeIndex, Validation>;
+export declare const defaultValidation: () => boolean;
+export declare const isValidId: (id: number) => boolean;
+export declare const isValidString: (v: any) => boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/def/validation.js

@@ -0,0 +1,259 @@
+import { convertToTimestamp } from '@saulx/utils';
+import { TYPE_INDEX_MAP } from './types.js';
+import { MAX_ID, MIN_ID } from '../types.js';
+const EPSILON = 1e-9; // Small tolerance for floating point comparisons
+export const VALIDATION_MAP = {
+    [TYPE_INDEX_MAP.alias]: (value) => {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.binary]: (value) => {
+        console.log('DERP ', value, typeof value);
+        if (value instanceof Uint8Array) {
+            return true;
+        }
+        return false;
+    },
+    [TYPE_INDEX_MAP.boolean]: (value) => {
+        if (typeof value !== 'boolean') {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.cardinality]: (val) => {
+        return (typeof val === 'string' ||
+            (val instanceof Uint8Array && val.byteLength === 8));
+    },
+    [TYPE_INDEX_MAP.timestamp]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (t.min !== undefined) {
+            if (typeof t.min === 'number') {
+                if (value < t.min) {
+                    return false;
+                }
+            }
+            else if (value < convertToTimestamp(t.min)) {
+                return false;
+            }
+        }
+        else {
+            return value > -1;
+        }
+        if (t.max !== undefined) {
+            if (typeof t.max === 'number') {
+                if (value > t.max) {
+                    return false;
+                }
+            }
+            else if (value > convertToTimestamp(t.max)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int16]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 32767 || value < -32768) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int32]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 2147483647 || value < -2147483648) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.int8]: (value, t) => {
+        // use % for steps size
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 127 || value < -128) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint8]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 255 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint16]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 65535 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.uint32]: (value, t) => {
+        if (typeof value !== 'number' || value % t.step !== 0) {
+            return false;
+        }
+        if (value > 4294967295 || value < 0) {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.number]: (value, t) => {
+        if (t.step) {
+            const div = value / t.step;
+            if (Math.abs(div - Math.round(div)) > EPSILON) {
+                return false;
+            }
+        }
+        if (typeof value !== 'number') {
+            return false;
+        }
+        if (t.min !== undefined && value < t.min) {
+            return false;
+        }
+        if (t.max !== undefined && value > t.max) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.enum]: (value, prop) => {
+        if (value === null) {
+            return true;
+        }
+        const arr = prop.enum;
+        for (let i = 0; i < arr.length; i++) {
+            if (value === arr[i]) {
+                return true;
+            }
+        }
+        return false;
+    },
+    [TYPE_INDEX_MAP.id]: (value) => {
+        if (typeof value !== 'number' || value % 1 !== 0) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.json]: (value) => {
+        return true;
+    },
+    [TYPE_INDEX_MAP.microbuffer]: (value) => {
+        if (!(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.reference]: (v) => {
+        if (typeof v !== 'number') {
+            return false;
+        }
+        if (v === 0 || v > MAX_ID) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.references]: (v) => {
+        if (typeof v !== 'number') {
+            return false;
+        }
+        if (v === 0 || v > MAX_ID) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.string]: (value, t) => {
+        // add max etc all here - make a ref to the original SCHEMA on DEF
+        if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.text]: (value, t) => {
+        // add max etc all here - make a ref to the original SCHEMA on DEF
+        if (typeof value !== 'string' && !(value instanceof Uint8Array)) {
+            return false;
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.aliases]: (value) => {
+        if (!Array.isArray(value)) {
+            return false;
+        }
+        const len = value.length;
+        for (let i = 0; i < len; i++) {
+            if (typeof value[i] !== 'string') {
+                return false;
+            }
+        }
+        return true;
+    },
+    [TYPE_INDEX_MAP.vector]: (value) => {
+        // Array should be supported
+        if (!(value instanceof Float32Array)) {
+            return false;
+        }
+        return true;
+    },
+};
+export const defaultValidation = () => true;
+export const isValidId = (id) => {
+    if (typeof id != 'number' || id < MIN_ID || id > MAX_ID) {
+        return false;
+    }
+    return true;
+};
+export const isValidString = (v) => {
+    const isVal = typeof v === 'string' ||
+        v instanceof Uint8Array ||
+        ArrayBuffer.isView(v);
+    return isVal;
+};
+//# sourceMappingURL=validation.js.map

package/dist/index.d.ts

@@ -1,5 +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,5 +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/lang.d.ts

@@ -144,8 +144,10 @@ declare const langCodes: {
     readonly yi: 142;
     readonly yo: 143;
     readonly zu: 144;
+    readonly ka: 145;
+    readonly cnr: 146;
 };
-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 | 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 | 145 | 146>;
 export declare const inverseLangMap: Map<any, any>;
 export type LangName = keyof typeof langCodes;
 export type LangCode = (typeof langCodes)[LangName];

package/dist/lang.js

@@ -144,6 +144,8 @@ const langCodes = {
     yi: 142,
     yo: 143,
     zu: 144,
+    ka: 145,
+    cnr: 146,
 };
 export const langCodesMap = new Map(Object.entries(langCodes));
 export const inverseLangMap = new 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/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;
@@ -63,6 +64,9 @@ export class SchemaParser {
         expectObject(locales);
         for (const locale in locales) {
             const opts = locales[locale];
+            if (opts === true) {
+                continue;
+            }
             expectObject(opts);
             for (const key in opts) {
                 const val = opts[key];
@@ -70,7 +74,7 @@ export class SchemaParser {
                     expectBoolean(val);
                 }
                 else if (key === 'fallback') {
-                    if (!Array.isArray(val) || !val.every((v) => typeof v === 'string')) {
+                    if (Array.isArray(val) || typeof val !== 'string') {
                         throw Error(INVALID_VALUE);
                     }
                 }
@@ -97,6 +101,7 @@ export class SchemaParser {
                 throw Error(UNKNOWN_PROP);
             }
         }
+        return this.schema;
     }
 }
 export const print = (schema, path) => {
@@ -120,9 +125,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.d.ts

@@ -3,5 +3,6 @@ import type { SchemaParser } from './index.js';
 type PropsFns<PropType> = Record<string, (val: any, prop: PropType, ctx: SchemaParser, key?: string) => void>;
 declare function propParser<PropType extends SchemaAnyProp>(required: PropsFns<PropType>, optional: PropsFns<PropType>, allowShorthand?: number): (prop: any, ctx: SchemaParser) => void;
 declare const p: Record<string, ReturnType<typeof propParser>>;
+export declare const isDefault: (val: any, prop: any, ctx: any) => any;
 export default p;
 //# sourceMappingURL=props.d.ts.map