@based/db 0.0.71 → 0.1.1

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

@@ -0,0 +1,46 @@
+import { deleteProp } from './delete.js';
+import { writeU32, writeU8, writeU8Array } from '../uint.js';
+import { validate } from '../validate.js';
+import { xxHash64 } from '../../xxHash64.js';
+import { ENCODER } from '@based/utils';
+import { reserve } from '../resize.js';
+import { PROP_CURSOR_SIZE, writePropCursor } from '../cursor.js';
+import { CREATE } from '../types.js';
+export const writeCardinalityRaw = (ctx, def, val, sizeFixBecauseEdgeIsDifferent = val.length) => {
+    writeU32(ctx, sizeFixBecauseEdgeIsDifferent);
+    for (const item of val) {
+        validate(def, item);
+        if (typeof item === 'string') {
+            xxHash64(ENCODER.encode(item), ctx.array, ctx.index);
+            ctx.index += 8;
+            continue;
+        }
+        if (item instanceof Uint8Array && item.byteLength === 8) {
+            writeU8Array(ctx, item);
+            continue;
+        }
+        throw [def, val];
+    }
+};
+export const writeCardinality = (ctx, def, val) => {
+    if (val === null) {
+        deleteProp(ctx, def);
+        return;
+    }
+    if (!Array.isArray(val)) {
+        val = [val];
+    }
+    if (val.length === 0) {
+        return;
+    }
+    const size = PROP_CURSOR_SIZE + 1 + 4 + val.length * 8;
+    reserve(ctx, PROP_CURSOR_SIZE + size + 1);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    writeCardinalityRaw(ctx, def, val);
+    if (ctx.operation === CREATE) {
+        ctx.schema.separateSort.bufferTmp[def.prop] = 2;
+        ctx.sort++;
+    }
+};
+//# sourceMappingURL=cardinality.js.map

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

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

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

@@ -0,0 +1,13 @@
+import { DELETE, UPDATE } from '../types.js';
+import { reserve } from '../resize.js';
+import { PROP_CURSOR_SIZE, writePropCursor } from '../cursor.js';
+import { writeU8 } from '../uint.js';
+export const deleteProp = (ctx, def) => {
+    if (ctx.operation !== UPDATE) {
+        return;
+    }
+    reserve(ctx, PROP_CURSOR_SIZE + 1);
+    writePropCursor(ctx, def);
+    writeU8(ctx, DELETE);
+};
+//# sourceMappingURL=delete.js.map

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

@@ -0,0 +1,4 @@
+import { Ctx } from '../Ctx.js';
+import { PropDef, PropDefEdge } from '@based/schema/def';
+export declare const writeFixed: (ctx: Ctx, def: PropDef | PropDefEdge, val: string | boolean | number) => void;
+export declare const writeFixedAtOffset: (ctx: Ctx, def: PropDef, val: string | boolean | number, offset: number) => void;

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

@@ -0,0 +1,105 @@
+import { BINARY, BOOLEAN, ENUM, INT16, INT32, INT8, NUMBER, STRING, TIMESTAMP, UINT16, UINT32, UINT8, } from '@based/schema/def';
+import { convertToTimestamp, ENCODER } from '@based/utils';
+import { getBuffer } from './binary.js';
+import { reserve } from '../resize.js';
+import { writeU16, writeU32, writeU64, writeU8, writeU8Array } from '../uint.js';
+import { validate } from '../validate.js';
+const map = {};
+map[BINARY] = (ctx, val, def) => {
+    val = getBuffer(val);
+    validate(def, val);
+    reserve(ctx, val.byteLength + 1);
+    writeU8(ctx, val.byteLength);
+    writeU8Array(ctx, val);
+};
+map[STRING] = (ctx, val, def) => {
+    const valBuf = ENCODER.encode(val);
+    const size = valBuf.byteLength;
+    if (size + 1 > def.len) {
+        throw [def, val, `max length of ${def.len - 1},`];
+    }
+    validate(def, val);
+    reserve(ctx, size + 1);
+    const fullSize = def.len - 1;
+    ctx.array[ctx.index] = size;
+    ctx.array.set(valBuf, ctx.index + 1);
+    ctx.index += fullSize + 1;
+    if (fullSize !== size) {
+        ctx.array.fill(0, ctx.index - (fullSize - size), ctx.index);
+    }
+};
+map[BOOLEAN] = (ctx, val, def) => {
+    val ??= def.default;
+    validate(def, val);
+    reserve(ctx, 1);
+    writeU8(ctx, val ? 1 : 0);
+};
+map[ENUM] = (ctx, val, def) => {
+    validate(def, val);
+    if (val === null) {
+        reserve(ctx, 1);
+        writeU8(ctx, def.default);
+    }
+    else if (val in def.reverseEnum) {
+        reserve(ctx, 1);
+        writeU8(ctx, def.reverseEnum[val] + 1);
+    }
+    else {
+        throw [def, val];
+    }
+};
+map[NUMBER] = (ctx, val, def) => {
+    val ??= def.default;
+    validate(def, val);
+    const view = new DataView(ctx.array.buffer, ctx.array.byteOffset + ctx.index, 8);
+    reserve(ctx, 8);
+    view.setFloat64(0, val, true);
+    ctx.index += 8;
+};
+map[TIMESTAMP] = (ctx, val, def) => {
+    val ??= def.default;
+    const parsedValue = convertToTimestamp(val);
+    validate(def, parsedValue);
+    reserve(ctx, 8);
+    writeU64(ctx, parsedValue);
+};
+map[UINT32] = (ctx, val, def) => {
+    val ??= def.default;
+    validate(def, val);
+    reserve(ctx, 4);
+    writeU32(ctx, val);
+};
+map[UINT16] = (ctx, val, def) => {
+    val ??= def.default;
+    validate(def, val);
+    reserve(ctx, 2);
+    writeU16(ctx, val);
+};
+map[UINT8] = map[INT8] = (ctx, val, def) => {
+    val ??= def.default;
+    validate(def, val);
+    reserve(ctx, 1);
+    writeU8(ctx, val);
+};
+map[INT32] = (ctx, val, def) => {
+    val ??= def.default;
+    validate(def, val);
+    reserve(ctx, 4);
+    writeU32(ctx, val);
+};
+map[INT16] = (ctx, val, def) => {
+    val ??= def.default;
+    validate(def, val);
+    reserve(ctx, 2);
+    writeU16(ctx, val);
+};
+export const writeFixed = (ctx, def, val) => {
+    return map[def.typeIndex](ctx, val, def);
+};
+export const writeFixedAtOffset = (ctx, def, val, offset) => {
+    const index = ctx.index;
+    ctx.index = offset;
+    map[def.typeIndex](ctx, val, def);
+    ctx.index = index;
+};
+//# sourceMappingURL=fixed.js.map

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

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

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

@@ -0,0 +1,28 @@
+import { PROP_CURSOR_SIZE, writeMainCursor } from '../cursor.js';
+import { writeU16, writeU8 } from '../uint.js';
+import { reserve } from '../resize.js';
+import { writeFixed } from './fixed.js';
+import { DECREMENT, INCREMENT } from '../types.js';
+export const writeIncrement = (ctx, def, val) => {
+    if (typeof val.increment !== 'number') {
+        throw [def, val];
+    }
+    if (val.increment === 0) {
+        return;
+    }
+    reserve(ctx, PROP_CURSOR_SIZE + 4 + def.len);
+    writeMainCursor(ctx);
+    if (val.increment > 0) {
+        writeU8(ctx, INCREMENT);
+        writeU8(ctx, def.typeIndex);
+        writeU16(ctx, def.start);
+        writeFixed(ctx, def, val.increment);
+    }
+    else {
+        writeU8(ctx, DECREMENT);
+        writeU8(ctx, def.typeIndex);
+        writeU16(ctx, def.start);
+        writeFixed(ctx, def, -val.increment);
+    }
+};
+//# sourceMappingURL=increment.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { writeBinary } from './binary.js';
+export const writeJson = (ctx, def, val) => {
+    writeBinary(ctx, def, val === null ? null : JSON.stringify(val), true);
+};
+//# sourceMappingURL=json.js.map

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

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

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

@@ -0,0 +1,22 @@
+import { writeFixedAtOffset } from './fixed.js';
+import { reserve } from '../resize.js';
+import { PROP_CURSOR_SIZE, writeMainCursor } from '../cursor.js';
+import { writeU32, writeU8, writeU8Array } from '../uint.js';
+export const writeMainBuffer = (ctx) => {
+    if (ctx.cursor.main === null) {
+        reserve(ctx, PROP_CURSOR_SIZE + 5 + ctx.schema.mainLen);
+        writeMainCursor(ctx);
+        writeU8(ctx, ctx.operation);
+        writeU32(ctx, ctx.schema.mainLen);
+        ctx.cursor.main = ctx.index;
+        writeU8Array(ctx, ctx.schema.mainEmpty);
+    }
+};
+export const writeMainValue = (ctx, def, val) => {
+    reserve(ctx, PROP_CURSOR_SIZE + 5 + ctx.schema.mainLen);
+    writeMainBuffer(ctx);
+    writeFixedAtOffset(ctx, def, typeof val === 'object' && val !== null && 'increment' in val
+        ? val.increment
+        : val, ctx.cursor.main + def.start);
+};
+//# sourceMappingURL=main.js.map

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

@@ -0,0 +1,3 @@
+import { SchemaTypeDef } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeObject: (ctx: Ctx, tree: SchemaTypeDef["tree"], obj: Record<string, any>) => void;

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

@@ -0,0 +1,37 @@
+import { isPropDef } from '@based/schema/def';
+import { writeSeparate } from './separate.js';
+import { writeMainValue } from './main.js';
+import { writeIncrement } from './increment.js';
+export const writeObject = (ctx, tree, obj) => {
+    for (const key in obj) {
+        const val = obj[key];
+        if (val === undefined) {
+            continue;
+        }
+        const def = tree[key];
+        if (def === undefined) {
+            if (ctx.unsafe) {
+                continue;
+            }
+            throw [tree, key];
+        }
+        if (!isPropDef(def)) {
+            writeObject(ctx, def, val);
+            continue;
+        }
+        if (def.separate) {
+            writeSeparate(ctx, def, val);
+            continue;
+        }
+        if (ctx.overwrite) {
+            writeMainValue(ctx, def, val);
+            continue;
+        }
+        if (typeof val === 'object' && val !== null) {
+            writeIncrement(ctx, def, val);
+            continue;
+        }
+        ctx.main.set(def, val);
+    }
+};
+//# sourceMappingURL=object.js.map

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

@@ -0,0 +1,6 @@
+import { PropDef } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+import { Tmp } from '../Tmp.js';
+export declare const writeReference: (ctx: Ctx, def: PropDef, val: number | Tmp | {
+    id: number | Tmp | Promise<any>;
+}) => void;

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

@@ -0,0 +1,92 @@
+import { Tmp } from '../Tmp.js';
+import { reserve } from '../resize.js';
+import { PROP_CURSOR_SIZE, writePropCursor } from '../cursor.js';
+import { EDGE_NOINDEX_REALID, EDGE_NOINDEX_TMPID, NOEDGE_NOINDEX_REALID, NOEDGE_NOINDEX_TMPID, } from '../types.js';
+import { writeEdges } from '../edges/index.js';
+import { deleteProp } from './delete.js';
+import { writeU32, writeU8 } from '../uint.js';
+const writeReferenceId = (ctx, def, val, refOp) => {
+    if (!def.validation(val, def)) {
+        throw [def, val];
+    }
+    reserve(ctx, PROP_CURSOR_SIZE + 6);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    writeU8(ctx, refOp);
+    writeU32(ctx, val);
+};
+export const writeReference = (ctx, def, val) => {
+    if (val === null) {
+        deleteProp(ctx, def);
+        return;
+    }
+    if (typeof val === 'number') {
+        if (def.hasDefaultEdges) {
+            writeReferenceId(ctx, def, val, EDGE_NOINDEX_REALID);
+            writeEdges(ctx, def, {}, true);
+        }
+        else {
+            writeReferenceId(ctx, def, val, NOEDGE_NOINDEX_REALID);
+        }
+        return;
+    }
+    if (typeof val === 'object') {
+        if (typeof val.id === 'object') {
+            if (val.id === null) {
+                throw [def, val];
+            }
+            if ('then' in val.id && typeof val.id.then === 'function') {
+                // @ts-ignore
+                const resolvedId = val.id.id;
+                if (resolvedId) {
+                    // @ts-ignore
+                    val.id = resolvedId;
+                }
+            }
+        }
+        if (typeof val.id === 'number') {
+            if (!def.edges || val instanceof Tmp || val instanceof Promise) {
+                writeReferenceId(ctx, def, val.id, NOEDGE_NOINDEX_REALID);
+            }
+            else {
+                writeReferenceId(ctx, def, val.id, EDGE_NOINDEX_REALID);
+                writeEdges(ctx, def, val, true);
+            }
+            return;
+        }
+        if (val.id instanceof Tmp) {
+            if (val.id.batch !== ctx.batch) {
+                throw val.id;
+            }
+            if (!def.edges) {
+                writeReferenceId(ctx, def, val.id.tmpId, NOEDGE_NOINDEX_TMPID);
+            }
+            else {
+                writeReferenceId(ctx, def, val.id.tmpId, EDGE_NOINDEX_TMPID);
+                writeEdges(ctx, def, val, true);
+            }
+            return;
+        }
+        if (val instanceof Tmp) {
+            if (val.batch !== ctx.batch) {
+                throw val;
+            }
+            if (def.hasDefaultEdges) {
+                writeReferenceId(ctx, def, val.tmpId, EDGE_NOINDEX_TMPID);
+                writeEdges(ctx, def, {}, true);
+            }
+            else {
+                writeReferenceId(ctx, def, val.tmpId, NOEDGE_NOINDEX_TMPID);
+            }
+            return;
+        }
+        if (val.id instanceof Promise) {
+            throw val.id;
+        }
+        if (val instanceof Promise) {
+            throw val;
+        }
+    }
+    throw [def, val];
+};
+//# sourceMappingURL=reference.js.map

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

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

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

@@ -0,0 +1,231 @@
+import { reserve } from '../resize.js';
+import { PROP_CURSOR_SIZE, writePropCursor } from '../cursor.js';
+import { writeU32, writeU8 } from '../uint.js';
+import { Tmp } from '../Tmp.js';
+import { validate } from '../validate.js';
+import { writeEdges } from '../edges/index.js';
+import { writeUint32 } from '@based/utils';
+import { DELETE, EDGE_INDEX_REALID, EDGE_INDEX_TMPID, EDGE_NOINDEX_REALID, EDGE_NOINDEX_TMPID, NOEDGE_INDEX_REALID, NOEDGE_INDEX_TMPID, NOEDGE_NOINDEX_REALID, NOEDGE_NOINDEX_TMPID, REF_OP_DELETE, REF_OP_OVERWRITE, REF_OP_PUT_ADD, REF_OP_PUT_OVERWRITE, REF_OP_UPDATE, } from '../types.js';
+const clearReferences = (ctx, def) => {
+    reserve(ctx, PROP_CURSOR_SIZE + 1);
+    writePropCursor(ctx, def);
+    writeU8(ctx, DELETE);
+};
+const hasEdgeOrIndex = (def, obj) => {
+    if (def.edges) {
+        for (const key in obj) {
+            if (key[0] === '$') {
+                return true;
+            }
+        }
+    }
+};
+const hasAnEdge = (def, obj) => {
+    if (def.hasDefaultEdges) {
+        return true;
+    }
+    if (def.edges) {
+        for (const key in obj) {
+            if (key[0] === '$' && key !== '$index') {
+                return true;
+            }
+        }
+    }
+};
+const putReferences = (ctx, def, val, refOp) => {
+    reserve(ctx, PROP_CURSOR_SIZE + 6 + val.length * 4);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    writeU32(ctx, val.length * 4 + 1);
+    writeU8(ctx, refOp === REF_OP_OVERWRITE ? REF_OP_PUT_OVERWRITE : REF_OP_PUT_ADD);
+    let index = 0;
+    for (const id of val) {
+        if (typeof id === 'number') {
+            validate(def, id);
+            writeU32(ctx, id);
+            index++;
+            continue;
+        }
+        if (typeof id === 'object' && id !== null && typeof id.id === 'number') {
+            if (hasEdgeOrIndex(def, id)) {
+                return index;
+            }
+            validate(def, id.id);
+            writeU32(ctx, id.id);
+            index++;
+            continue;
+        }
+        return index;
+    }
+    return index;
+};
+const updateReferences = (ctx, def, val, index, length, refOp) => {
+    reserve(ctx, PROP_CURSOR_SIZE + 6 + val.length * 9);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    const sizeIndex = ctx.index;
+    ctx.index += 4;
+    const start = ctx.index;
+    writeU8(ctx, index > 0 ? REF_OP_UPDATE : refOp);
+    writeU32(ctx, length);
+    while (length--) {
+        let id = val[index++];
+        if (def.hasDefaultEdges) {
+            if (typeof id === 'number' ||
+                id instanceof Tmp ||
+                id instanceof Promise) {
+                id = { id: id };
+            }
+        }
+        if (typeof id === 'number') {
+            validate(def, id);
+            writeU8(ctx, NOEDGE_NOINDEX_REALID);
+            writeU32(ctx, id);
+            continue;
+        }
+        if (typeof id !== 'object' || id === null) {
+            throw [def, val];
+        }
+        if (typeof id.then === 'function') {
+            if (id.id) {
+                validate(def, id.id);
+                writeU8(ctx, NOEDGE_NOINDEX_REALID);
+                writeU32(ctx, id.id);
+                continue;
+            }
+            if (id instanceof Tmp && id.batch === ctx.batch) {
+                writeU8(ctx, NOEDGE_NOINDEX_TMPID);
+                writeU32(ctx, id.tmpId);
+                continue;
+            }
+            throw id;
+        }
+        if (typeof id.id === 'number') {
+            writeReferenceObj(ctx, def, id.id, id, false);
+            continue;
+        }
+        if (typeof id.id !== 'object' || id.id === null) {
+            throw [def, val];
+        }
+        if (typeof id.id.then === 'function') {
+            if (id.id.id) {
+                writeReferenceObj(ctx, def, id.id.id, id, false);
+                continue;
+            }
+            if (id.id instanceof Tmp && id.id.batch === ctx.batch) {
+                writeReferenceObj(ctx, def, id.id.tmpId, id, true);
+                continue;
+            }
+            throw id.id;
+        }
+    }
+    writeUint32(ctx.array, ctx.index - start, sizeIndex);
+};
+const putOrUpdateReferences = (ctx, def, val, refOp) => {
+    if (!val.length) {
+        clearReferences(ctx, def);
+        return;
+    }
+    if (def.hasDefaultEdges) {
+        updateReferences(ctx, def, val, 0, val.length, refOp);
+        return;
+    }
+    const start = ctx.index;
+    const index = putReferences(ctx, def, val, refOp);
+    if (index === val.length) {
+        // did all
+        return;
+    }
+    if (index === 0) {
+        // did nothing
+        ctx.index = start;
+        ctx.cursor.prop = null;
+        updateReferences(ctx, def, val, 0, val.length, refOp);
+    }
+    else {
+        // did partial
+        ctx.cursor.prop = null;
+        updateReferences(ctx, def, val, index, val.length - index, refOp);
+    }
+};
+const writeReferenceObj = (ctx, def, id, obj, isTmp) => {
+    const hasIndex = typeof obj.$index === 'number';
+    const hasEdges = hasAnEdge(def, obj);
+    validate(def, id);
+    if (hasIndex) {
+        if (hasEdges) {
+            writeU8(ctx, isTmp ? EDGE_INDEX_TMPID : EDGE_INDEX_REALID);
+            writeU32(ctx, id);
+            writeU32(ctx, obj.$index);
+            writeEdges(ctx, def, obj, false);
+        }
+        else {
+            writeU8(ctx, isTmp ? NOEDGE_INDEX_TMPID : NOEDGE_INDEX_REALID);
+            writeU32(ctx, id);
+            writeU32(ctx, obj.$index);
+        }
+    }
+    else if (hasEdges) {
+        writeU8(ctx, isTmp ? EDGE_NOINDEX_TMPID : EDGE_NOINDEX_REALID);
+        writeU32(ctx, id);
+        writeEdges(ctx, def, obj, false);
+    }
+    else {
+        writeU8(ctx, isTmp ? NOEDGE_NOINDEX_TMPID : NOEDGE_NOINDEX_REALID);
+        writeU32(ctx, id);
+    }
+};
+const deleteReferences = (ctx, def, val) => {
+    const size = 4 * val.length + 1;
+    reserve(ctx, PROP_CURSOR_SIZE + 6 + size);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    writeU32(ctx, size);
+    writeU8(ctx, REF_OP_DELETE);
+    for (const id of val) {
+        if (typeof id === 'number') {
+            validate(def, id);
+            writeU32(ctx, id);
+            continue;
+        }
+        if (id === null ||
+            typeof id !== 'object' ||
+            typeof id.then !== 'function') {
+            throw [def, val];
+        }
+        if (typeof id.id === 'number') {
+            writeU32(ctx, id.id);
+            continue;
+        }
+        throw id.id || id;
+    }
+};
+export const writeReferences = (ctx, def, val) => {
+    if (typeof val !== 'object') {
+        throw [def, val];
+    }
+    if (val === null) {
+        clearReferences(ctx, def);
+        return;
+    }
+    if (Array.isArray(val)) {
+        putOrUpdateReferences(ctx, def, val, REF_OP_OVERWRITE);
+        return;
+    }
+    for (const key in val) {
+        const arr = val[key];
+        if (!Array.isArray(arr)) {
+            throw [def, val];
+        }
+        if (key === 'update' || key === 'add') {
+            putOrUpdateReferences(ctx, def, arr, REF_OP_UPDATE);
+            continue;
+        }
+        if (key === 'delete') {
+            deleteReferences(ctx, def, arr);
+            continue;
+        }
+        throw [def, val];
+    }
+};
+//# sourceMappingURL=references.js.map

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

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

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

@@ -0,0 +1,43 @@
+import { STRING, TEXT, REFERENCE, REFERENCES, BINARY, ALIAS, CARDINALITY, VECTOR, COLVEC, JSON, } from '@based/schema/def';
+import { writeReference } from './reference.js';
+import { writeString } from './string.js';
+import { writeText } from './text.js';
+import { writeReferences } from './references.js';
+import { writeBinary } from './binary.js';
+import { writeAlias } from './alias.js';
+import { writeCardinality } from './cardinality.js';
+import { writeVector } from './vector.js';
+import { writeJson } from './json.js';
+import { markDefaults } from '../create/mark.js';
+export const writeSeparate = (ctx, def, val) => {
+    const type = def.typeIndex;
+    if (type === STRING) {
+        writeString(ctx, def, val, 0);
+    }
+    else if (type === TEXT) {
+        writeText(ctx, def, val);
+    }
+    else if (type === REFERENCE) {
+        writeReference(ctx, def, val);
+    }
+    else if (type === REFERENCES) {
+        writeReferences(ctx, def, val);
+    }
+    else if (type === BINARY) {
+        writeBinary(ctx, def, val);
+    }
+    else if (type === ALIAS) {
+        writeAlias(ctx, def, val);
+    }
+    else if (type === CARDINALITY) {
+        writeCardinality(ctx, def, val);
+    }
+    else if (type === VECTOR || type === COLVEC) {
+        writeVector(ctx, def, val);
+    }
+    else if (type === JSON) {
+        writeJson(ctx, def, val);
+    }
+    markDefaults(ctx, def, val);
+};
+//# sourceMappingURL=separate.js.map

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

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