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

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/dist/types.d.ts

@@ -1,4 +1,5 @@
 import { LangName } from './lang.js';
+import { Validation } from './def/validation.js';
 type Role = 'title' | 'source' | 'media' | string;
 export declare const numberDisplays: readonly ["short", "human", "ratio", "bytes", "euro", "dollar", "pound", "meter"];
 export declare const dateDisplays: readonly ["date", "date-time", "date-time-text", "date-time-human", "time", "time-precise"];
@@ -14,6 +15,7 @@ type QueryFn = Function;
 type PropValues = {
     type?: string;
     default?: any;
+    validation?: Validation;
 };
 type Prop<V extends PropValues> = {
     required?: boolean;
@@ -24,6 +26,7 @@ type Prop<V extends PropValues> = {
     role?: Role;
     readOnly?: boolean;
     examples?: string[];
+    validation?: Validation;
 } & V;
 type EnumItem = string | number | boolean;
 type NeverInItems = {
@@ -31,15 +34,19 @@ type NeverInItems = {
 };
 export type SchemaReferences = Prop<{
     type?: 'references';
+    default?: number[];
     items: SchemaReference & NeverInItems;
 }>;
 export type SchemaReferencesOneWay = Prop<{
     type?: 'references';
+    default?: number[];
     items: SchemaReferenceOneWay & NeverInItems;
 }>;
 export type SchemaText = Prop<{
     type: 'text';
     default?: Record<string, string>;
+    format?: StringFormat;
+    compression?: 'none' | 'deflate';
 }>;
 type NumberType = 'number' | 'int8' | 'uint8' | 'int16' | 'uint16' | 'int32' | 'uint32';
 export type SchemaNumber = Prop<{
@@ -65,7 +72,7 @@ export type SchemaString = Prop<{
 }>;
 export type SchemaBinary = Prop<{
     type: 'binary';
-    default?: ArrayBuffer;
+    default?: Uint8Array;
     maxBytes?: number;
     mime?: Mime;
     format?: StringFormat;
@@ -80,7 +87,6 @@ export type SchemaBoolean = Prop<{
 }>;
 export type SchemaCardinality = Prop<{
     type: 'cardinality';
-    default?: string;
     maxBytes?: number;
     mime?: Mime;
     format?: NumberDisplay;
@@ -92,19 +98,22 @@ export type SchemaVector = Prop<{
 }>;
 export type SchemaTimestamp = Prop<{
     type: 'timestamp';
-    default?: number | Date;
+    default?: number | Date | string;
     on?: 'create' | 'update';
     display?: DateDisplay;
+    min?: number | string;
+    max?: number | string;
+    step?: number | 'any' | string;
 }>;
 export type SchemaReferenceOneWay = Prop<{
     type?: 'reference';
-    default?: string;
+    default?: number;
     ref: string;
     mime?: Mime;
 }>;
 export type SchemaReference = Prop<{
     type?: 'reference';
-    default?: string;
+    default?: number;
     ref: string;
     prop: string;
     dependent?: boolean;
@@ -126,7 +135,7 @@ export type SchemaReferencesWithQuery = SchemaReferencesOneWay & {
 };
 export type SchemaEnum = Prop<{
     type?: 'enum';
-    default?: EnumItem;
+    default?: EnumItem | undefined;
     enum: EnumItem[];
 }>;
 export type SchemaAlias = Omit<SchemaString, 'type'> & {
@@ -176,9 +185,9 @@ type GenericSchema<isStrict = false> = {
 };
 export type StrictSchema = GenericSchema<true>;
 export type Schema = GenericSchema<false> | StrictSchema;
-export type SchemaLocales = Record<LangName, {
+export type SchemaLocales = Record<LangName, true | {
     required?: boolean;
-    fallback?: LangName[];
+    fallback?: LangName;
 }>;
 export type SchemaPropTypeMap = {
     references: SchemaReferences;
@@ -198,5 +207,7 @@ export type SchemaPropTypeMap = {
 } & Record<NumberType, SchemaNumber>;
 export type SchemaPropTypes = keyof SchemaPropTypeMap;
 export declare const isPropType: <T extends SchemaPropTypes>(type: T, prop: SchemaProp) => prop is SchemaPropTypeMap[T];
+export declare const MAX_ID = 4294967295;
+export declare const MIN_ID = 1;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -95,4 +95,6 @@ export const stringFormats = [
 export const isPropType = (type, prop) => {
     return getPropType(prop) === type;
 };
+export const MAX_ID = 4294967295;
+export const MIN_ID = 1;
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.2",
+  "version": "5.0.0-alpha.20",
   "license": "MIT",
-  "main": "dist/index.js",
   "files": [
     "dist",
     "README.md",
     "package.json",
     "!dist/**/*.map"
   ],
+  "main": "./dist/index.js",
+  "exports": {
+    "./def": "./dist/def/index.js",
+    ".": "./dist/index.js"
+  },
   "scripts": {
     "build": "tsc",
     "watch": "tsc --watch",
-    "test": "tsc && tsc test/*.ts --noEmit && tsx --test test/*.ts",
-    "test1": "tsc && tsc $npm_config --noEmit && tsx --test $npm_config"
+    "test": "tsc && tsc $npm_config --noEmit && tsx --test $npm_config"
   },
   "prettier": "@saulx/prettier-config",
   "sideEffects": false,
@@ -26,6 +29,8 @@
     "typescript": "^5.6.3"
   },
   "dependencies": {
+    "fflate": "0.8.1",
+    "@saulx/utils": "^6.7.0",
     "picocolors": "^1.1.0"
   }
 }

package/dist/mermaid.d.ts

@@ -1,3 +0,0 @@
-import { StrictSchema } from './types.js';
-export declare const mermaid: (schema: StrictSchema) => string;
-//# sourceMappingURL=mermaid.d.ts.map

package/dist/mermaid.js

@@ -1,24 +0,0 @@
-import { getPropType } from './parse/utils.js';
-import { isPropType } from './types.js';
-export const mermaid = (schema) => {
-    let mermaid = 'classDiagram';
-    if (schema.types) {
-        for (const type in schema.types) {
-            for (const key in schema.types[type].props) {
-                const prop = schema.types[type].props[key];
-                const propType = getPropType(prop);
-                if (isPropType('reference', prop)) {
-                    mermaid += `\n${type} --> ${prop.ref} : ${key}`;
-                }
-                else if (isPropType('references', prop)) {
-                    mermaid += `\n${type} --> ${prop.items.ref} : ${key}[]`;
-                }
-                else {
-                    mermaid += `\n${type} : ${propType} ${key}`;
-                }
-            }
-        }
-    }
-    return mermaid;
-};
-//# sourceMappingURL=mermaid.js.map