@based/db 0.0.71 → 0.1.0

package/dist/src/client/modify/drain.d.ts

@@ -0,0 +1,7 @@
+import { DbClient } from '../../index.js';
+import { Ctx } from './Ctx.js';
+export declare const reset: (ctx: Ctx) => void;
+export declare const cancel: (ctx: Ctx, error: Error) => void;
+export declare const consume: (ctx: Ctx) => Uint8Array;
+export declare const drain: (db: DbClient, ctx: Ctx) => Promise<void>;
+export declare const schedule: (db: DbClient, ctx: Ctx) => Promise<void>;

package/dist/src/client/modify/drain.js

@@ -0,0 +1,77 @@
+import { writeUint16, writeUint32 } from '@based/utils';
+import { rejectTmp, resolveTmp } from './Tmp.js';
+export const reset = (ctx) => {
+    ctx.index = 8;
+    ctx.max = ctx.array.buffer.maxByteLength - 4;
+    ctx.size = ctx.array.buffer.byteLength - 4;
+    ctx.cursor = {};
+    ctx.created = {};
+    ctx.batch = {};
+};
+export const cancel = (ctx, error) => {
+    const { batch } = ctx;
+    reset(ctx);
+    batch.error = error;
+    batch.promises?.forEach(rejectTmp);
+};
+export const consume = (ctx) => {
+    if (ctx.index > ctx.array.byteLength) {
+        throw new Error('Invalid size - modify buffer length mismatch');
+    }
+    const typeIds = Object.keys(ctx.created);
+    const typeSize = typeIds.length * 6 + 4;
+    const payload = ctx.array.subarray(0, ctx.index + typeSize);
+    let i = payload.byteLength - 4;
+    writeUint32(payload, ctx.index, i);
+    for (const typeId of typeIds) {
+        const count = ctx.created[typeId];
+        i -= 6;
+        writeUint16(payload, Number(typeId), i);
+        writeUint32(payload, count, i + 2);
+    }
+    reset(ctx);
+    return payload;
+};
+export const drain = (db, ctx) => {
+    if (ctx.index > 8) {
+        const { batch } = ctx;
+        const payload = consume(ctx);
+        ctx.draining = db.hooks
+            .flushModify(payload)
+            .then(({ offsets, dbWriteTime }) => {
+            db.writeTime += dbWriteTime ?? 0;
+            batch.ready = true;
+            batch.offsets = offsets;
+            batch.promises?.forEach(resolveTmp);
+            batch.promises = null;
+        })
+            .catch((e) => {
+            console.error(e);
+            batch.ready = true;
+            batch.error = e;
+            batch.promises?.forEach(rejectTmp);
+            batch.promises = null;
+        });
+    }
+    return ctx.draining;
+};
+export const schedule = (db, ctx) => {
+    if (ctx.scheduled || ctx.index === 8) {
+        return ctx.scheduled;
+    }
+    ctx.scheduled = new Promise((resolve) => {
+        if (db.flushTime === 0) {
+            process.nextTick(() => {
+                ctx.scheduled = null;
+                resolve(drain(db, ctx));
+            });
+        }
+        else {
+            setTimeout(() => {
+                ctx.scheduled = null;
+                resolve(drain(db, ctx));
+            }, db.flushTime);
+        }
+    });
+};
+//# sourceMappingURL=drain.js.map

package/dist/src/client/modify/edges/binary.d.ts

@@ -0,0 +1,3 @@
+import { PropDefEdge } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeBinaryEdge: (ctx: Ctx, edge: PropDefEdge, val: any) => void;

package/dist/src/client/modify/edges/binary.js

@@ -0,0 +1,28 @@
+import { STRING } from '@based/schema/def';
+import { reserve } from '../resize.js';
+import { getBuffer, writeBinaryRaw } from '../props/binary.js';
+import { writeU32 } from '../uint.js';
+import { writeEdgeHeader } from './header.js';
+import { PROP_CURSOR_SIZE } from '../cursor.js';
+export const writeBinaryEdge = (ctx, edge, val) => {
+    let size = 0;
+    if (val !== null) {
+        const buf = getBuffer(val);
+        if (!buf || !edge.validation(buf, edge)) {
+            throw [edge, val];
+        }
+        size = buf.byteLength;
+        val = buf;
+    }
+    if (size) {
+        reserve(ctx, PROP_CURSOR_SIZE + size + 10);
+        writeEdgeHeader(ctx, edge, STRING);
+        writeBinaryRaw(ctx, val);
+    }
+    else {
+        reserve(ctx, 3 + 4);
+        writeEdgeHeader(ctx, edge, STRING);
+        writeU32(ctx, 0);
+    }
+};
+//# sourceMappingURL=binary.js.map

package/dist/src/client/modify/edges/cardinality.d.ts

@@ -0,0 +1,3 @@
+import { PropDefEdge } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeCardinalityEdge: (ctx: Ctx, edge: PropDefEdge, val: any) => void;

package/dist/src/client/modify/edges/cardinality.js

@@ -0,0 +1,15 @@
+import { CARDINALITY } from '@based/schema/def';
+import { reserve } from '../resize.js';
+import { writeEdgeHeader } from './header.js';
+import { writeCardinalityRaw } from '../props/cardinality.js';
+import { PROP_CURSOR_SIZE } from '../cursor.js';
+export const writeCardinalityEdge = (ctx, edge, val) => {
+    if (!Array.isArray(val)) {
+        val = [val];
+    }
+    const size = 4 + val.length * 8;
+    reserve(ctx, PROP_CURSOR_SIZE + size);
+    writeEdgeHeader(ctx, edge, CARDINALITY);
+    writeCardinalityRaw(ctx, edge, val, size);
+};
+//# sourceMappingURL=cardinality.js.map

package/dist/src/client/modify/edges/header.d.ts

@@ -0,0 +1,5 @@
+import { PropDefEdge } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeEdgeHeader: (ctx: Ctx, edge: PropDefEdge, type: number) => void;
+export declare const writeEdgeHeaderMain: (ctx: Ctx) => void;
+export declare const writeEdgeHeaderPartial: (ctx: Ctx) => void;

package/dist/src/client/modify/edges/header.js

@@ -0,0 +1,21 @@
+import { MICRO_BUFFER } from '@based/schema/def';
+import { UPDATE, UPDATE_PARTIAL } from '../types.js';
+export const writeEdgeHeader = (ctx, edge, type) => {
+    ctx.array[ctx.index] = UPDATE;
+    ctx.array[ctx.index + 1] = edge.prop;
+    ctx.array[ctx.index + 2] = type;
+    ctx.index += 3;
+};
+export const writeEdgeHeaderMain = (ctx) => {
+    ctx.array[ctx.index] = UPDATE;
+    ctx.array[ctx.index + 1] = 0;
+    ctx.array[ctx.index + 2] = MICRO_BUFFER;
+    ctx.index += 3;
+};
+export const writeEdgeHeaderPartial = (ctx) => {
+    ctx.array[ctx.index] = UPDATE_PARTIAL;
+    ctx.array[ctx.index + 1] = 0;
+    ctx.array[ctx.index + 2] = MICRO_BUFFER;
+    ctx.index += 3;
+};
+//# sourceMappingURL=header.js.map

package/dist/src/client/modify/edges/index.d.ts

@@ -0,0 +1,3 @@
+import { PropDef } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeEdges: (ctx: Ctx, def: PropDef, obj: Record<string, any>, isSingleRefFix: boolean) => void;

package/dist/src/client/modify/edges/index.js

@@ -0,0 +1,128 @@
+import { writeSeparateEdge } from './separate.js';
+import { DECREMENT, INCREMENT, UPDATE } from '../types.js';
+import { writeEdgeHeaderMain, writeEdgeHeaderPartial } from './header.js';
+import { writeU16, writeU32 } from '../uint.js';
+import { writeFixed } from '../props/fixed.js';
+import { writeUint16, writeUint32 } from '@based/utils';
+import { reserve } from '../resize.js';
+import { PROP_CURSOR_SIZE } from '../cursor.js';
+const setDefaultEdges = (def, val) => {
+    if (def.hasDefaultEdges) {
+        for (const key in def.edges) {
+            const edge = def.edges[key];
+            if (edge.separate && val[key] === undefined) {
+                val[key] = edge.default;
+            }
+        }
+    }
+};
+export const writeEdges = (ctx, def, obj, isSingleRefFix) => {
+    const index = ctx.index;
+    ctx.index += 4;
+    const start = ctx.index;
+    let hasIncr = false;
+    let mainSize = 0;
+    let mainFields;
+    let operation;
+    setDefaultEdges(def, obj);
+    for (const key in obj) {
+        let val = obj[key];
+        if (key === 'id' || key === '$index' || val === undefined) {
+            continue;
+        }
+        const edge = def.edges[key];
+        if (!edge) {
+            throw [def, obj];
+        }
+        if (edge.separate) {
+            writeSeparateEdge(ctx, edge, val);
+            continue;
+        }
+        if (typeof val !== 'object' || val === null) {
+            operation = UPDATE;
+        }
+        else if (val.increment > 0) {
+            operation = INCREMENT;
+            hasIncr = true;
+            val = val.increment;
+        }
+        else if (val.increment < 0) {
+            operation = DECREMENT;
+            hasIncr = true;
+            val = val.increment;
+        }
+        else {
+            throw [edge, val];
+        }
+        if (!hasIncr && def.edgeMainLen === edge.len) {
+            reserve(ctx, 3 + 4 + edge.len);
+            writeEdgeHeaderMain(ctx);
+            writeU32(ctx, edge.len);
+            writeFixed(ctx, edge, val);
+        }
+        else {
+            mainSize += edge.len;
+            if (mainFields) {
+                const len = mainFields.length;
+                for (let i = 0; i < len; i += 3) {
+                    if (edge.start < mainFields[i].start) {
+                        mainFields.splice(i, 0, edge, val, operation);
+                        break;
+                    }
+                    else if (mainFields[len - i - 3].start < edge.start) {
+                        mainFields.splice(len - i, 0, edge, val, operation);
+                        break;
+                    }
+                }
+            }
+            else {
+                mainFields = [edge, val, operation];
+            }
+        }
+    }
+    if (mainFields || def.hasDefaultEdges) {
+        if (!hasIncr && mainSize === def.edgeMainLen) {
+            reserve(ctx, 3 + 4 + mainSize);
+            writeEdgeHeaderMain(ctx);
+            writeU32(ctx, mainSize);
+            for (let i = 0; i < mainFields.length; i += 3) {
+                const edge = mainFields[i];
+                const val = mainFields[i + 1];
+                writeFixed(ctx, edge, val);
+            }
+        }
+        else {
+            mainFields ??= [];
+            const mainFieldsStartSize = mainFields.length * 2;
+            reserve(ctx, PROP_CURSOR_SIZE + 4 + 2 + mainFieldsStartSize + def.edgeMainLen);
+            writeEdgeHeaderPartial(ctx);
+            writeU32(ctx, mainFieldsStartSize + def.edgeMainLen);
+            writeU16(ctx, def.edgeMainLen);
+            // Index of start of fields
+            const sIndex = ctx.index;
+            ctx.index += mainFieldsStartSize;
+            // Add zeroes
+            ctx.array.set(def.edgeMainEmpty, ctx.index);
+            // Keep track of written bytes from append fixed
+            let startMain = ctx.index;
+            for (let i = 0; i < mainFields.length; i += 3) {
+                const edge = mainFields[i];
+                const value = mainFields[i + 1];
+                const operation = mainFields[i + 2];
+                const sIndexI = i * 2 + sIndex;
+                writeUint16(ctx.array, edge.start, sIndexI);
+                writeUint16(ctx.array, edge.len, sIndexI + 2);
+                ctx.array[sIndexI + 4] = operation;
+                ctx.array[sIndexI + 5] = edge.typeIndex;
+                ctx.index = startMain + edge.start;
+                // Add null support (defaults)
+                writeFixed(ctx, edge, value);
+            }
+            // Correction append fixed value writes the len
+            ctx.index = startMain + def.edgeMainLen;
+        }
+    }
+    const size = ctx.index - start + (isSingleRefFix ? 4 : 0);
+    writeUint32(ctx.array, size, index);
+};
+//# sourceMappingURL=index.js.map

package/dist/src/client/modify/edges/reference.d.ts

@@ -0,0 +1,3 @@
+import { PropDefEdge } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeReferenceEdge: (ctx: Ctx, edge: PropDefEdge, val: any) => void;

package/dist/src/client/modify/edges/reference.js

@@ -0,0 +1,31 @@
+import { REFERENCE } from '@based/schema/def';
+import { reserve } from '../resize.js';
+import { writeU32 } from '../uint.js';
+import { writeEdgeHeader } from './header.js';
+export const writeReferenceEdge = (ctx, edge, val) => {
+    if (val === null) {
+        reserve(ctx, 3 + 4);
+        writeEdgeHeader(ctx, edge, REFERENCE);
+        writeU32(ctx, 0);
+        return;
+    }
+    if (typeof val === 'object') {
+        if (val.id) {
+            val = val.id;
+        }
+        else if (typeof val.then === 'function') {
+            throw val;
+        }
+    }
+    if (typeof val === 'number') {
+        if (!edge.validation(val, edge)) {
+            throw [edge, val];
+        }
+        reserve(ctx, 3 + 4);
+        writeEdgeHeader(ctx, edge, REFERENCE);
+        writeU32(ctx, val);
+        return;
+    }
+    throw [edge, val];
+};
+//# sourceMappingURL=reference.js.map

package/dist/src/client/modify/edges/references.d.ts

@@ -0,0 +1,3 @@
+import { PropDefEdge } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeReferencesEdge: (ctx: Ctx, edge: PropDefEdge, vals: any) => void;

package/dist/src/client/modify/edges/references.js

@@ -0,0 +1,38 @@
+import { REFERENCES } from '@based/schema/def';
+import { reserve } from '../resize.js';
+import { writeU32 } from '../uint.js';
+import { writeEdgeHeader } from './header.js';
+export const writeReferencesEdge = (ctx, edge, vals) => {
+    if (vals === null) {
+        reserve(ctx, 3 + 4);
+        writeEdgeHeader(ctx, edge, REFERENCES);
+        writeU32(ctx, 0);
+        return;
+    }
+    if (!Array.isArray(vals)) {
+        throw [edge, vals];
+    }
+    const size = vals.length * 4;
+    reserve(ctx, 3 + 4 + size);
+    writeEdgeHeader(ctx, edge, REFERENCES);
+    writeU32(ctx, size);
+    for (let val of vals) {
+        if (typeof val === 'object') {
+            if (val.id) {
+                val = val.id;
+            }
+            else if (typeof val.then === 'function') {
+                throw val;
+            }
+        }
+        if (typeof val === 'number') {
+            if (!edge.validation(val, edge)) {
+                throw [edge, vals];
+            }
+            writeU32(ctx, val);
+            continue;
+        }
+        throw [edge, vals];
+    }
+};
+//# sourceMappingURL=references.js.map

package/dist/src/client/modify/edges/separate.d.ts

@@ -0,0 +1,3 @@
+import { PropDefEdge } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeSeparateEdge: (ctx: Ctx, edge: PropDefEdge, val: any) => void;

package/dist/src/client/modify/edges/separate.js

@@ -0,0 +1,24 @@
+import { BINARY, STRING, REFERENCE, REFERENCES, CARDINALITY, } from '@based/schema/def';
+import { writeBinaryEdge } from './binary.js';
+import { writeStringEdge } from './string.js';
+import { writeReferenceEdge } from './reference.js';
+import { writeReferencesEdge } from './references.js';
+import { writeCardinalityEdge } from './cardinality.js';
+export const writeSeparateEdge = (ctx, edge, val) => {
+    if (edge.typeIndex === BINARY) {
+        writeBinaryEdge(ctx, edge, val);
+    }
+    else if (edge.typeIndex === STRING) {
+        writeStringEdge(ctx, edge, val);
+    }
+    else if (edge.typeIndex === REFERENCE) {
+        writeReferenceEdge(ctx, edge, val);
+    }
+    else if (edge.typeIndex === REFERENCES) {
+        writeReferencesEdge(ctx, edge, val);
+    }
+    else if (edge.typeIndex === CARDINALITY) {
+        writeCardinalityEdge(ctx, edge, val);
+    }
+};
+//# sourceMappingURL=separate.js.map

package/dist/src/client/modify/edges/string.d.ts

@@ -0,0 +1,3 @@
+import { PropDefEdge } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeStringEdge: (ctx: Ctx, edge: PropDefEdge, val: any) => void;

package/dist/src/client/modify/edges/string.js

@@ -0,0 +1,30 @@
+import { STRING } from '@based/schema/def';
+import { ENCODER } from '@based/utils';
+import { write } from '../../string.js';
+import { reserve } from '../resize.js';
+import { RANGE_ERR } from '../types.js';
+import { writeU32 } from '../uint.js';
+import { writeEdgeHeader } from './header.js';
+export const writeStringEdge = (ctx, edge, val) => {
+    if (val === null) {
+        reserve(ctx, 3 + 4);
+        writeEdgeHeader(ctx, edge, STRING);
+        writeU32(ctx, 0);
+        return;
+    }
+    if (!edge.validation(val, edge)) {
+        throw [val, edge];
+    }
+    const maxSize = val instanceof Uint8Array
+        ? val.byteLength
+        : ENCODER.encode(val).byteLength + 6;
+    reserve(ctx, 3 + maxSize + 4);
+    writeEdgeHeader(ctx, edge, STRING);
+    const realSize = write(ctx, val, ctx.index + 4, !edge.compression);
+    if (realSize === null) {
+        throw RANGE_ERR;
+    }
+    writeU32(ctx, realSize);
+    ctx.index += realSize;
+};
+//# sourceMappingURL=string.js.map

package/dist/src/client/modify/error.d.ts

@@ -0,0 +1,7 @@
+import { DbClient } from '../../index.js';
+import { create } from './create/index.js';
+import { Ctx } from './Ctx.js';
+import { del } from './delete/index.js';
+import { expire } from './expire/index.js';
+import { update } from './update/index.js';
+export declare const handleError: (db: DbClient, ctx: Ctx, fn: typeof create | typeof update | typeof del | typeof expire, args: IArguments, e: any) => Promise<number>;

package/dist/src/client/modify/error.js

@@ -0,0 +1,68 @@
+import { isPropDef, REVERSE_TYPE_INDEX_MAP, } from '@based/schema/def';
+import { drain } from './drain.js';
+import { Tmp } from './Tmp.js';
+import { RANGE_ERR } from './types.js';
+const MAGIC_KEY = Math.random().toString(36).substring(2);
+const MAGIC_REG = RegExp(`("${MAGIC_KEY}|${MAGIC_KEY}")`, 'g');
+const walk = (val) => {
+    if (typeof val === 'object' && val !== null) {
+        if (Array.isArray(val)) {
+            return val.map(walk);
+        }
+        const obj = {};
+        for (const key in val) {
+            obj[MAGIC_KEY + key + MAGIC_KEY] = walk(val[key]);
+        }
+        return obj;
+    }
+    return val;
+};
+const parseVal = (val) => {
+    if (typeof val === 'object' && val !== null) {
+        const str = JSON.stringify(walk(val)).replace(MAGIC_REG, '');
+        val = str;
+    }
+    if (typeof val === 'string' && val.length > 35) {
+        return val.slice(0, 35) + `... (${val.length - 35} more characters)`;
+    }
+    return val;
+};
+const parseErrorMsg = (prop, val, msg) => {
+    if (isPropDef(prop)) {
+        if (msg) {
+            return `Invalid value at '${prop.path.join('.')}'. Expected ${msg} received '${parseVal(val)}'`;
+        }
+        return `Invalid value at '${prop.path.join('.')}'. Expected ${REVERSE_TYPE_INDEX_MAP[prop.typeIndex]}, received '${parseVal(val)}'`;
+    }
+    return `Unknown property '${val}'. Expected one of: ${Object.keys(prop).join(', ')}`;
+};
+export const handleError = (db, ctx, fn, args, e) => {
+    ctx.index = ctx.start;
+    ctx.cursor = {};
+    if (e === RANGE_ERR) {
+        if (ctx.start === 8) {
+            throw 'Out of range. Not enough space for this payload';
+        }
+        drain(db, ctx);
+        return fn.apply(null, args);
+    }
+    if (typeof e.then === 'function') {
+        if (e.id)
+            process.exit();
+        return e.then((id) => {
+            if (!(e instanceof Tmp)) {
+                e.id = id;
+            }
+            return fn.apply(null, args);
+        });
+    }
+    if (typeof e === 'string') {
+        throw Error(e);
+    }
+    if (Array.isArray(e)) {
+        const [def, val, msg] = e;
+        throw Error(parseErrorMsg(def, val, msg));
+    }
+    throw e;
+};
+//# sourceMappingURL=error.js.map

package/dist/src/client/modify/expire/index.d.ts

@@ -0,0 +1,2 @@
+import { DbClient } from '../../../index.js';
+export declare function expire(db: DbClient, type: string, id: number, seconds: number): Promise<number>;

package/dist/src/client/modify/expire/index.js

@@ -0,0 +1,31 @@
+import { getValidSchema, validateId } from '../validate.js';
+import { handleError } from '../error.js';
+import { reserve } from '../resize.js';
+import { NODE_CURSOR_SIZE, TYPE_CURSOR_SIZE, writeNodeCursor, writeTypeCursor, } from '../cursor.js';
+import { EXPIRE } from '../types.js';
+import { schedule } from '../drain.js';
+import { Tmp } from '../Tmp.js';
+import { writeU32, writeU8 } from '../uint.js';
+export function expire(db, type, id, seconds) {
+    const ctx = db.modifyCtx;
+    const schema = getValidSchema(db, type);
+    try {
+        ctx.id = id;
+        ctx.start = ctx.index;
+        ctx.schema = schema;
+        ctx.operation = EXPIRE;
+        validateId(id);
+        reserve(ctx, TYPE_CURSOR_SIZE + NODE_CURSOR_SIZE + 5);
+        writeTypeCursor(ctx);
+        writeNodeCursor(ctx);
+        writeU8(ctx, EXPIRE);
+        writeU32(ctx, seconds);
+        const tmp = new Tmp(ctx, id);
+        schedule(db, ctx);
+        return tmp;
+    }
+    catch (e) {
+        return handleError(db, ctx, expire, arguments, e);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/src/client/modify/props/alias.d.ts

@@ -0,0 +1,3 @@
+import { PropDef } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeAlias: (ctx: Ctx, def: PropDef, val: any) => void;

package/dist/src/client/modify/props/alias.js

@@ -0,0 +1,26 @@
+import { deleteProp } from './delete.js';
+import { validate } from '../validate.js';
+import { ENCODER } from '@based/utils';
+import { reserve } from '../resize.js';
+import { PROP_CURSOR_SIZE, writePropCursor } from '../cursor.js';
+import { writeU32, writeU8, writeU8Array } from '../uint.js';
+import { markString } from '../create/mark.js';
+export const writeAlias = (ctx, def, val) => {
+    if (val === null) {
+        deleteProp(ctx, def);
+        return;
+    }
+    validate(def, val);
+    const buf = ENCODER.encode(val);
+    if (buf.byteLength === 0) {
+        deleteProp(ctx, def);
+        return;
+    }
+    reserve(ctx, PROP_CURSOR_SIZE + 5 + buf.byteLength);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    writeU32(ctx, buf.byteLength);
+    writeU8Array(ctx, buf);
+    markString(ctx, def);
+};
+//# sourceMappingURL=alias.js.map

package/dist/src/client/modify/props/binary.d.ts

@@ -0,0 +1,5 @@
+import { PropDef } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const getBuffer: (val: any) => Uint8Array;
+export declare const writeBinaryRaw: (ctx: Ctx, val: Uint8Array) => void;
+export declare const writeBinary: (ctx: Ctx, def: PropDef, val: any, validated?: boolean) => void;

package/dist/src/client/modify/props/binary.js

@@ -0,0 +1,52 @@
+import { writeU16, writeU32, writeU8, writeU8Array } from '../uint.js';
+import { PROP_CURSOR_SIZE, writePropCursor } from '../cursor.js';
+import { validate } from '../validate.js';
+import native from '../../../native.js';
+import { reserve } from '../resize.js';
+import { deleteProp } from './delete.js';
+import { ENCODER } from '@based/utils';
+export const getBuffer = (val) => {
+    if (typeof val === 'string') {
+        return ENCODER.encode(val);
+    }
+    if (typeof val !== 'object') {
+        return;
+    }
+    if (val instanceof Uint8Array) {
+        return val;
+    }
+    if (val.buffer instanceof ArrayBuffer) {
+        return new Uint8Array(val.buffer, 0, val.byteLength);
+    }
+};
+export const writeBinaryRaw = (ctx, val) => {
+    const size = val.byteLength + 6;
+    const crc = native.crc32(val);
+    writeU32(ctx, size);
+    writeU16(ctx, 0);
+    writeU8Array(ctx, val);
+    writeU32(ctx, crc);
+};
+export const writeBinary = (ctx, def, val, validated) => {
+    if (val === null) {
+        deleteProp(ctx, def);
+        return;
+    }
+    const buf = getBuffer(val);
+    if (buf === undefined) {
+        throw [def, val];
+    }
+    if (!validated) {
+        validate(def, buf);
+    }
+    if (!buf.byteLength) {
+        deleteProp(ctx, def);
+        return;
+    }
+    const size = buf.byteLength + 6;
+    reserve(ctx, PROP_CURSOR_SIZE + size + 11);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    writeBinaryRaw(ctx, buf);
+};
+//# sourceMappingURL=binary.js.map

package/dist/src/client/modify/props/cardinality.d.ts

@@ -0,0 +1,4 @@
+import { PropDef, PropDefEdge } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeCardinalityRaw: (ctx: Ctx, def: PropDef | PropDefEdge, val: any[], sizeFixBecauseEdgeIsDifferent?: number) => void;
+export declare const writeCardinality: (ctx: Ctx, def: PropDef, val: any) => void;