@based/schema 5.0.0-alpha.23 → 5.0.0-alpha.24

package/dist/def/typeDef.js

@@ -115,6 +115,9 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 default: schemaProp.default ?? DEFAULT_MAP[typeIndex],
                 prop: isseparate ? ++result.cnt : 0,
             };
+            if (schemaProp.transform) {
+                prop.transform = schemaProp.transform;
+            }
             if (schemaProp.max !== undefined) {
                 prop.max = parseMinMaxStep(schemaProp.max);
             }
@@ -196,6 +199,7 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
             }
         }
         let len = 2;
+        let biggestSeperatePropDefault = 0;
         for (const f of vals) {
             if (f.separate) {
                 len += 2;
@@ -203,9 +207,15 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 if (f.default !== undefined) {
                     result.hasSeperateDefaults = true;
                     if (!result.seperateDefaults) {
-                        // result.seperateDefaults = []
+                        result.seperateDefaults = {
+                            props: new Map(),
+                            bufferTmp: new Uint8Array(),
+                        };
+                    }
+                    result.seperateDefaults.props.set(f.prop, f);
+                    if (f.prop > biggestSeperatePropDefault) {
+                        biggestSeperatePropDefault = f.prop;
                     }
-                    // result.seperateDefaults.push(f)
                 }
             }
             else {
@@ -218,6 +228,9 @@ export const createSchemaTypeDef = (typeName, type, parsed, locales, result = cr
                 setByPath(result.tree, f.path, f);
             }
         }
+        if (result.hasSeperateDefaults) {
+            result.seperateDefaults.bufferTmp = new Uint8Array(biggestSeperatePropDefault + 1);
+        }
         result.mainEmpty = fillEmptyMain(vals, result.mainLen);
         result.mainEmptyAllZeroes = isZeroes(result.mainEmpty);
         if (result.separateSortText > 0) {

package/dist/def/types.d.ts

@@ -1,5 +1,6 @@
 import type { LangCode, SchemaLocales } from '../index.js';
 import { Validation } from './validation.js';
+export type Transform = (type: 'create' | 'update' | 'read' | 'filter' | 'search', value: any) => any;
 export declare const NULL = 0;
 export declare const TIMESTAMP = 1;
 export declare const NUMBER = 4;
@@ -82,6 +83,7 @@ export type PropDef = {
     enum?: any[];
     dependent?: boolean;
     validation: Validation;
+    transform?: Transform;
     default: any;
     edgeMainLen?: 0;
     reverseEnum?: {

package/dist/def/validation.js

@@ -182,6 +182,7 @@ export const VALIDATION_MAP = {
         return true;
     },
     [TYPE_INDEX_MAP.json]: (value) => {
+        // mep
         return true;
     },
     [TYPE_INDEX_MAP.microbuffer]: (value) => {

package/dist/parse/props.js

@@ -58,6 +58,9 @@ const shared = {
     validation(val) {
         expectFunction(val);
     },
+    transform(val) {
+        expectFunction(val);
+    },
 };
 function propParser(required, optional, allowShorthand) {
     return (prop, ctx) => {
@@ -132,6 +135,28 @@ export const isDefault = (val, prop, ctx) => {
         max: parseMinMaxStep(prop.max),
         min: parseMinMaxStep(prop.min),
     };
+    if (prop.type === 'text') {
+        if (typeof val === 'object') {
+            for (const key in val) {
+                if (!ctx.schema.locales || !(key in ctx.schema.locales)) {
+                    throw new Error(`Incorrect default for type "text" lang "${key}"`);
+                }
+                if (!validation(val[key], propDef)) {
+                    throw new Error(`Incorrect default for type "text" lang "${key}"`);
+                }
+            }
+        }
+        else {
+            if (!validation(val, propDef)) {
+                throw new Error(`Incorrect default for type "text"`);
+            }
+            val = {};
+            for (const key in ctx.schema.locales) {
+                val[key] = ctx.schema.locales[key];
+            }
+        }
+        return val;
+    }
     if (!validation(val, propDef)) {
         throw new Error(`Incorrect default for type "${prop.type ?? 'enum'}"`);
     }
@@ -313,13 +338,11 @@ p.text = propParser({
     },
 }, {
     compression(val) {
-        // return the actualy string!
         return val;
     },
     format: binaryOpts.format,
-    default(_val, _prop) {
-        // console.warn('MAKE DEFAULT VALUE FOR TEXT')
-        return true;
+    default(val, prop, ctx) {
+        return isDefault(val, prop, ctx);
     },
 }, 0);
 p.timestamp = propParser(STUB, {

package/dist/serialize.js

@@ -120,36 +120,50 @@ const handleSingleValue = (ops, val, obj, prev, fromObject, key) => {
     }
 };
 const encodeKey = (key, schemaBuffer) => {
-    let address = schemaBuffer.dictMap[key];
+    let dictKey = schemaBuffer.dictMap[key];
     // if len == 1 never from address
-    if (!address) {
+    if (!dictKey) {
+        dictKey = {
+            changed: 0,
+            address: 0,
+            // used: [],
+        };
         // pessimistically assume 4 bytes per char for UTF-8 to be safe.
         ensureCapacity(1 + key.length * 4);
-        address = schemaBuffer.len;
+        dictKey.address = schemaBuffer.len;
         schemaBuffer.len += 1;
         const r = ENCODER.encodeInto(key, schemaBuffer.buf.subarray(schemaBuffer.len));
-        schemaBuffer.buf[address] = r.written + KEY_OPTS;
+        schemaBuffer.buf[dictKey.address] = r.written + KEY_OPTS;
         schemaBuffer.len += r.written;
-        schemaBuffer.dictMap[key] = address;
+        // USED is the problem now
+        schemaBuffer.dictMapArr.push(dictKey);
+        schemaBuffer.dictMap[key] = dictKey;
     }
     else {
         ensureCapacity(4);
-        if (address > 65025) {
+        // updated address? maybe
+        const dictMapUsed = { address: schemaBuffer.len, key: dictKey };
+        schemaBuffer.dictMapUsed.push(dictMapUsed);
+        // used can be handled differently - also pass to
+        // dictKey.used.push(dictMapUsed)
+        // console.log('USE KEY!', key)
+        // have to check this to correct - correctly
+        if (dictKey.address > 65025) {
             schemaBuffer.buf[schemaBuffer.len] = KEY_ADDRESS_3_BYTES;
             schemaBuffer.len += 1;
-            writeUint24(schemaBuffer.buf, address, schemaBuffer.len);
+            writeUint24(schemaBuffer.buf, dictKey.address, schemaBuffer.len);
             schemaBuffer.len += 3;
         }
-        else if (address > 255) {
+        else if (dictKey.address > 255) {
             schemaBuffer.buf[schemaBuffer.len] = KEY_ADDRESS_2_BYTES;
             schemaBuffer.len += 1;
-            writeUint16(schemaBuffer.buf, address, schemaBuffer.len);
+            writeUint16(schemaBuffer.buf, dictKey.address, schemaBuffer.len);
             schemaBuffer.len += 2;
         }
         else {
             schemaBuffer.buf[schemaBuffer.len] = KEY_ADDRESS_1_BYTE;
             schemaBuffer.len += 1;
-            schemaBuffer.buf[schemaBuffer.len] = address;
+            schemaBuffer.buf[schemaBuffer.len] = dictKey.address;
             schemaBuffer.len += 1;
         }
     }
@@ -173,7 +187,7 @@ const walk = (opts, obj, prev, prev2, fromObject, schemaBuffer) => {
         schemaBuffer.buf[schemaBuffer.len++] = isArray ? ARRAY : OBJECT;
     }
     let sizeIndex = schemaBuffer.len;
-    schemaBuffer.len += 5;
+    schemaBuffer.len += 4;
     if (isArray) {
         const len = obj.length;
         ensureCapacity(2 * len + 2);
@@ -270,30 +284,67 @@ const walk = (opts, obj, prev, prev2, fromObject, schemaBuffer) => {
         }
     }
     let size = schemaBuffer.len - start;
-    // 3
-    // if (size < 252) {
-    //   console.log('FLAP>', size)
-    //   schemaBuffer.buf[sizeIndex] = size + 3
-    //   schemaBuffer.buf.set(
-    //     schemaBuffer.buf.subarray(sizeIndex + 4, sizeIndex + size),
-    //     sizeIndex + 1,
-    //   )
-    //   schemaBuffer.len -= 4
-    // } else {
-    schemaBuffer.buf[sizeIndex] = 0; // means 4
-    writeUint32(schemaBuffer.buf, size, sizeIndex + 1);
-    // }
+    // 3 different sizes? 3, 2, 1 ?
+    if (size < 252) {
+        schemaBuffer.keyChangeIndex++;
+        schemaBuffer.buf[sizeIndex] = size; // + 3 - 3
+        for (let i = schemaBuffer.dictMapArr.length - 1; i > -1; i--) {
+            const keyDict = schemaBuffer.dictMapArr[i];
+            if (keyDict.address < start) {
+                break;
+            }
+            else {
+                keyDict.changed = schemaBuffer.keyChangeIndex;
+                keyDict.address -= 3;
+            }
+        }
+        for (let i = schemaBuffer.dictMapUsed.length - 1; i > -1; i--) {
+            const keyDictUsed = schemaBuffer.dictMapUsed[i];
+            if (keyDictUsed.address < start) {
+                break;
+            }
+            else {
+                const keyDict = keyDictUsed.key;
+                if (keyDict.changed === schemaBuffer.keyChangeIndex) {
+                    const addressSize = schemaBuffer.buf[keyDictUsed.address];
+                    //  aslo correct if its smaller...  :|
+                    if (addressSize === KEY_ADDRESS_3_BYTES) {
+                        writeUint24(schemaBuffer.buf, keyDict.address, keyDictUsed.address + 1);
+                    }
+                    else if (addressSize === KEY_ADDRESS_2_BYTES) {
+                        writeUint16(schemaBuffer.buf, keyDict.address, keyDictUsed.address + 1);
+                    }
+                    else if (addressSize === KEY_ADDRESS_1_BYTE) {
+                        schemaBuffer.buf[keyDictUsed.address + 1] = keyDict.address;
+                    }
+                }
+                keyDictUsed.address -= 3;
+            }
+        }
+        schemaBuffer.buf.copyWithin(sizeIndex + 1, sizeIndex + 4, sizeIndex + size);
+        schemaBuffer.len -= 3;
+    }
+    else {
+        schemaBuffer.buf[sizeIndex] = 0; // means 4
+        writeUint24(schemaBuffer.buf, size, sizeIndex + 1);
+    }
 };
 export const serialize = (schema, opts = {}) => {
     if (!schemaBuffer) {
         schemaBuffer = {
-            buf: new Uint8Array(10e3), // 10kb default
+            buf: new Uint8Array(5e3), // 5kb default
             len: 0,
             dictMap: {},
+            dictMapArr: [],
+            dictMapUsed: [],
+            keyChangeIndex: 0,
         };
     }
+    schemaBuffer.keyChangeIndex = 0;
     schemaBuffer.len = 0;
     schemaBuffer.dictMap = {};
+    schemaBuffer.dictMapArr = [];
+    schemaBuffer.dictMapUsed = [];
     // defalte not supported in unpacking yet
     const isDeflate = 0; // opts.deflate ? 1 : 0
     walk(opts, schema, undefined, undefined, false, schemaBuffer);
@@ -302,6 +353,7 @@ export const serialize = (schema, opts = {}) => {
     //   // add extra byte! see if nessecary
     //   return deflate.deflateSync(packed)
     // } else {
+    // console.log('USED', schemaBuffer.dictMapUsed.length)
     return packed;
     // }
 };
@@ -348,12 +400,11 @@ export const deSerializeInner = (buf, obj, start, fromArray) => {
     }
     let size;
     if (buf[i] === 0) {
-        size = readUint32(buf, i + 1);
-        i += 5;
+        size = readUint24(buf, i + 1);
+        i += 4;
     }
     else {
         size = buf[i] - 3;
-        console.log('yo', size);
         i += 1;
     }
     const end = size + start;

package/dist/types.d.ts

@@ -1,9 +1,10 @@
 import { LangName } from './lang.js';
 import { Validation } from './def/validation.js';
+import { Transform } from './def/types.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"];
-export declare const stringFormats: readonly ["alpha", "alphaLocales", "alphanumeric", "alphanumericLocales", "ascii", "base32", "base58", "base64", "BIC", "btcAddress", "clike", "code", "creditCard", "css", "currency", "dataURI", "EAN", "email", "ethereumAddress", "FQDN", "hexadecimal", "hexColor", "HSL", "html", "IBAN", "identityCard", "IMEI", "IP", "IPRange", "ISBN", "ISIN", "ISO31661Alpha2", "ISO31661Alpha3", "ISO4217", "ISO6391", "ISO8601", "ISRC", "ISSN", "javascript", "json", "JWT", "latLong", "licensePlate", "lowercase", "luhnNumber", "MACAddress", "magnetURI", "markdown", "MD5", "mimeType", "mobilePhone", "mobilePhoneLocales", "octal", "passportNumber", "port", "postalCode", "postalCodeLocales", "python", "RFC3339", "rgbColor", "rust", "semVer", "slug", "strongPassword", "surrogatePair", "taxID", "typescript", "uppercase", "URL", "UUID", "VAT", "multiline"];
+export declare const stringFormats: readonly ["alpha", "alphaLocales", "alphanumeric", "alphanumericLocales", "ascii", "base32", "base58", "base64", "BIC", "btcAddress", "clike", "code", "creditCard", "css", "currency", "dataURI", "EAN", "email", "ethereumAddress", "FQDN", "hexadecimal", "hexColor", "HSL", "html", "IBAN", "identityCard", "IMEI", "IP", "IPRange", "ISBN", "ISIN", "ISO31661Alpha2", "ISO31661Alpha3", "ISO4217", "ISO6391", "ISO8601", "ISRC", "ISSN", "javascript", "json", "JWT", "latLong", "licensePlate", "lowercase", "luhnNumber", "MACAddress", "magnetURI", "markdown", "MD5", "mimeType", "mobilePhone", "mobilePhoneLocales", "octal", "password", "passportNumber", "port", "postalCode", "postalCodeLocales", "python", "RFC3339", "rgbColor", "rust", "semVer", "slug", "surrogatePair", "taxID", "typescript", "uppercase", "URL", "UUID", "VAT", "multiline"];
 type DateDisplay = (typeof dateDisplays)[number];
 type NumberDisplay = (typeof numberDisplays)[number] | `round-${number}`;
 type StringFormat = (typeof stringFormats)[number];
@@ -16,6 +17,7 @@ type PropValues = {
     type?: string;
     default?: any;
     validation?: Validation;
+    transform?: Transform;
 };
 type Prop<V extends PropValues> = {
     required?: boolean;
@@ -27,6 +29,7 @@ type Prop<V extends PropValues> = {
     readOnly?: boolean;
     examples?: string[];
     validation?: Validation;
+    transform?: Transform;
 } & V;
 type EnumItem = string | number | boolean;
 type NeverInItems = {

package/dist/types.js

@@ -71,6 +71,7 @@ export const stringFormats = [
     'mobilePhone',
     'mobilePhoneLocales',
     'octal',
+    'password',
     'passportNumber',
     'port',
     'postalCode',
@@ -81,7 +82,6 @@ export const stringFormats = [
     'rust',
     'semVer',
     'slug',
-    'strongPassword',
     'surrogatePair',
     'taxID',
     'typescript',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "5.0.0-alpha.23",
+  "version": "5.0.0-alpha.24",
   "license": "MIT",
   "files": [
     "dist",