@dabble/patches 0.1.1

package/dist/json-patch/types.d.ts

@@ -0,0 +1,52 @@
+export interface JSONPatchOpHandler {
+    like: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
+    apply(state: State, path: string, valueOrFrom: any): string | void;
+    transform(state: State, other: JSONPatchOp, ops: JSONPatchOp[]): JSONPatchOp[];
+    invert(state: State, op: JSONPatchOp, value: any, changedObj: any, isIndex: boolean): JSONPatchOp;
+    compose?(state: State, value1: any, value2: any): any;
+}
+export interface JSONPatchOpHandlerMap {
+    [key: string]: JSONPatchOpHandler;
+}
+export interface ApplyJSONPatchOptions {
+    /**
+     * Do not reject patches if error occurs (partial patching)
+     */
+    partial?: boolean;
+    /**
+     * Throw an exception if an error occurs when patching
+     */
+    strict?: boolean;
+    /**
+     * Stop on error and return the original object (without throwing an exception)
+     */
+    rigid?: boolean;
+    /**
+     * Don't log errors when they occurs during patching, if strict is not true, errors will be logged if this is false
+     */
+    silent?: boolean;
+    /**
+     * Saves the patch that caused the error to this property of the options object
+     */
+    error?: JSONPatchOp;
+    /**
+     * Apply changes at a given path prefix
+     */
+    atPath?: string;
+}
+export interface JSONPatchOp {
+    op: string;
+    path: string;
+    from?: string;
+    value?: any;
+    soft?: boolean;
+}
+export interface Root {
+    '': any;
+}
+export type State = {
+    root: Root;
+    types: JSONPatchOpHandlerMap;
+    cache: Set<any> | null;
+};
+export type Runner = (state: State) => any;

package/dist/json-patch/types.js

@@ -0,0 +1 @@
+export {};

package/dist/json-patch/utils/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any): boolean;

package/dist/json-patch/utils/deepEqual.js

@@ -0,0 +1,33 @@
+export function deepEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!(a && b) || typeof a !== 'object' || typeof b !== 'object') {
+        return false;
+    }
+    if (a.length !== b.length) {
+        return false;
+    }
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b)) {
+            return false;
+        }
+        for (let i = 0, imax = a.length; i < imax; i++) {
+            if (!deepEqual(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const aKeys = Object.keys(a);
+    if (aKeys.length !== Object.keys(b).length) {
+        return false;
+    }
+    for (let j = 0, jmax = aKeys.length; j < jmax; j++) {
+        const key = aKeys[j];
+        if (!deepEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/json-patch/utils/exit.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyJSONPatchOptions, JSONPatchOp, State } from '../types.js';
+export declare function exit(state: State, object: any, patch: JSONPatchOp, opts: ApplyJSONPatchOptions): any;

package/dist/json-patch/utils/exit.js

@@ -0,0 +1,4 @@
+export function exit(state, object, patch, opts) {
+    opts.error = patch;
+    return opts.partial && state.root ? state.root[''] : object;
+}

package/dist/json-patch/utils/get.d.ts

@@ -0,0 +1,2 @@
+import type { State } from '../types.js';
+export declare function get(state: State, path: string): any;

package/dist/json-patch/utils/get.js

@@ -0,0 +1,6 @@
+import { getOpData } from './getOpData.js';
+export function get(state, path) {
+    // eslint-disable-next-line no-unused-vars
+    const [keys, lastKey, target] = getOpData(state, path);
+    return target ? target[lastKey] : undefined;
+}

package/dist/json-patch/utils/getOpData.d.ts

@@ -0,0 +1,2 @@
+import type { State } from '../types.js';
+export declare function getOpData(state: State, path: string, createMissingObjects?: boolean): any[];

package/dist/json-patch/utils/getOpData.js

@@ -0,0 +1,10 @@
+import { EMPTY, pluck } from './pluck.js';
+import { toKeys } from './toKeys.js';
+export function getOpData(state, path, createMissingObjects) {
+    const keys = toKeys(path);
+    const lastKey = keys[keys.length - 1];
+    let target = pluck(state, keys);
+    if (createMissingObjects)
+        target = target || EMPTY;
+    return [keys, lastKey, target];
+}

package/dist/json-patch/utils/getType.d.ts

@@ -0,0 +1,3 @@
+import type { JSONPatchOp, State } from '../types.js';
+export declare function getType(state: State, patch: JSONPatchOp): import("../types.js").JSONPatchOpHandler;
+export declare function getTypeLike(state: State, patch: JSONPatchOp): "replace" | "add" | "remove" | "move" | "copy" | "test";

package/dist/json-patch/utils/getType.js

@@ -0,0 +1,6 @@
+export function getType(state, patch) {
+    return state.types?.[patch.op];
+}
+export function getTypeLike(state, patch) {
+    return state.types?.[patch.op]?.like;
+}

package/dist/json-patch/utils/index.d.ts

@@ -0,0 +1,14 @@
+export * from './deepEqual.js';
+export * from './get.js';
+export * from './getOpData.js';
+export * from './getType.js';
+export * from './log.js';
+export * from './ops.js';
+export * from './paths.js';
+export * from './pluck.js';
+export * from './shallowCopy.js';
+export * from './softWrites.js';
+export * from './toArrayIndex.js';
+export * from './toKeys.js';
+export * from './updateArrayIndexes.js';
+export * from './updateArrayPath.js';

package/dist/json-patch/utils/index.js

@@ -0,0 +1,14 @@
+export * from './deepEqual.js';
+export * from './get.js';
+export * from './getOpData.js';
+export * from './getType.js';
+export * from './log.js';
+export * from './ops.js';
+export * from './paths.js';
+export * from './pluck.js';
+export * from './shallowCopy.js';
+export * from './softWrites.js';
+export * from './toArrayIndex.js';
+export * from './toKeys.js';
+export * from './updateArrayIndexes.js';
+export * from './updateArrayPath.js';

package/dist/json-patch/utils/log.d.ts

@@ -0,0 +1,2 @@
+export declare function verbose(value: boolean): void;
+export declare function log(...rest: any[]): void;

package/dist/json-patch/utils/log.js

@@ -0,0 +1,7 @@
+let displayLogs = false;
+export function verbose(value) {
+    displayLogs = value;
+}
+export function log(...rest) {
+    displayLogs && console.log(...rest);
+}

package/dist/json-patch/utils/ops.d.ts

@@ -0,0 +1,14 @@
+import type { JSONPatchOp, State } from '../types.js';
+/**
+ * Check whether this operation is an add operation of some sort (add, copy, move).
+ */
+export declare function isAdd(state: State, op: JSONPatchOp, pathName: 'from' | 'path'): boolean;
+/**
+ * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
+ */
+export declare function mapAndFilterOps(ops: JSONPatchOp[], iterator: (op: JSONPatchOp, index: number, breakAfter: (keepRest?: boolean) => {}) => JSONPatchOp | JSONPatchOp[] | null): JSONPatchOp[];
+/**
+ * Remove operations that apply to a value which was removed.
+ */
+export declare function updateRemovedOps(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean, updatableObject?: boolean, opOp?: string, customHandler?: (op: JSONPatchOp) => any): JSONPatchOp[];
+export declare function transformRemove(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean): JSONPatchOp[];

package/dist/json-patch/utils/ops.js

@@ -0,0 +1,103 @@
+import { getTypeLike } from './getType.js';
+import { log } from './log.js';
+import { isArrayPath } from './paths.js';
+import { updateArrayIndexes } from './updateArrayIndexes.js';
+/**
+ * Check whether this operation is an add operation of some sort (add, copy, move).
+ */
+export function isAdd(state, op, pathName) {
+    const like = getTypeLike(state, op);
+    return (like === 'add' || like === 'copy' || like === 'move') && pathName === 'path';
+}
+/**
+ * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
+ */
+export function mapAndFilterOps(ops, iterator) {
+    let changed = false;
+    const mapped = [];
+    let shouldBreak = false;
+    let keepRest;
+    const breakAfter = (keep) => (shouldBreak = true) && (keepRest = keep);
+    for (let i = 0; i < ops.length; i++) {
+        const original = ops[i];
+        // If an op was copied or moved to the same path, it is a no-op and should be removed
+        if (original.from === original.path) {
+            if (!changed)
+                changed = true;
+            continue;
+        }
+        let value = iterator(original, i, breakAfter);
+        if (value && !Array.isArray(value) && value.from === value.path)
+            value = null;
+        if (!changed && value !== original)
+            changed = true;
+        if (Array.isArray(value))
+            mapped.push(...value);
+        else if (value)
+            mapped.push(value);
+        if (shouldBreak) {
+            if (keepRest)
+                mapped.push(...ops.slice(i + 1));
+            break;
+        }
+    }
+    return changed ? mapped : ops;
+}
+/**
+ * Remove operations that apply to a value which was removed.
+ */
+export function updateRemovedOps(state, thisPath, otherOps, isRemove = false, updatableObject = false, opOp, customHandler) {
+    const softPrefixes = new Set();
+    return mapAndFilterOps(otherOps, (op, index, breakAfter) => {
+        const opLike = getTypeLike(state, op);
+        const canMergeCustom = customHandler && opOp === op.op;
+        if (thisPath === op.path && opLike !== 'remove' && !canMergeCustom && !op.soft) {
+            // Once an operation sets this value again, we can assume the following ops were working on that and not the
+            // old value so they can be kept
+            if (op.op !== 'test') {
+                breakAfter(true); // stop and keep the remaining ops as-is
+            }
+            return op;
+        }
+        const { path, from } = op;
+        if (path === thisPath && canMergeCustom) {
+            const customOp = customHandler(op);
+            if (customOp)
+                return customOp;
+        }
+        if (isRemove && !updatableObject && from === thisPath) {
+            // Because of the check above, moves and copies will only hit here when the "from" field matches
+            if (opLike === 'move') {
+                // We need the rest of the otherOps to be adjusted against this "move"
+                breakAfter();
+                return transformRemove(state, op.path, otherOps.slice(index + 1));
+            }
+            else if (opLike === 'copy') {
+                // We need future ops on the copied object to be removed
+                breakAfter();
+                let rest = transformRemove(state, thisPath, otherOps.slice(index + 1));
+                rest = transformRemove(state, op.path, rest);
+                return rest;
+            }
+        }
+        if (op.soft && path === thisPath) {
+            softPrefixes.add(path);
+            return null;
+        }
+        const samePath = (!updatableObject && path === thisPath) || (!softPrefixes.has(thisPath) && path.startsWith(`${thisPath}/`));
+        const sameFrom = (!updatableObject && from === thisPath) || (!softPrefixes.has(thisPath) && from?.startsWith(`${thisPath}/`));
+        if (samePath || sameFrom) {
+            log('Removing', op);
+            return null;
+        }
+        return op;
+    });
+}
+export function transformRemove(state, thisPath, otherOps, isRemove) {
+    if (isArrayPath(thisPath, state)) {
+        return updateArrayIndexes(state, thisPath, otherOps, -1, isRemove);
+    }
+    else {
+        return updateRemovedOps(state, thisPath, otherOps, isRemove);
+    }
+}

package/dist/json-patch/utils/paths.d.ts

@@ -0,0 +1,9 @@
+import type { State } from '../types.js';
+export declare function getPrefix(path: string): string;
+export declare function getProp(path: string): string;
+export declare function getPrefixAndProp(path: string): [string, string];
+export declare function getPropAfter(path: string, index: number): string;
+export declare function isArrayPath(path: string, state?: State): boolean;
+export declare function getArrayPrefixAndIndex(state: State, path: string, pathLength?: number): [string, number];
+export declare function getArrayIndex(state: State, path: string, pathLength?: number): number;
+export declare function getIndexAndEnd(state: State, path: string | undefined, maxLength: number): number[];

package/dist/json-patch/utils/paths.js

@@ -0,0 +1,53 @@
+import { getOpData } from './getOpData.js';
+const arrayPathExp = /\/(0|[1-9]\d*)$/;
+const EMPTY = [];
+export function getPrefix(path) {
+    const lastSlash = path.lastIndexOf('/');
+    return path.slice(0, lastSlash + 1);
+}
+export function getProp(path) {
+    const lastSlash = path.lastIndexOf('/');
+    return path.slice(lastSlash + 1);
+}
+export function getPrefixAndProp(path) {
+    const prefix = getPrefix(path);
+    return [prefix, path.slice(prefix.length)];
+}
+export function getPropAfter(path, index) {
+    const lastSlash = path.indexOf('/', index);
+    return path.slice(index, lastSlash === -1 ? undefined : lastSlash);
+}
+export function isArrayPath(path, state) {
+    if (!arrayPathExp.test(path))
+        return false;
+    if (!state || !state.root || !state.root[''])
+        return true;
+    // Double-check if this is an array or not
+    const [_, __, target] = getOpData(state, path);
+    return Array.isArray(target) || target == null;
+}
+export function getArrayPrefixAndIndex(state, path, pathLength) {
+    if (pathLength)
+        path = path.slice(0, path.indexOf('/', pathLength));
+    if (!arrayPathExp.test(path))
+        return EMPTY;
+    const [_, __, target] = getOpData(state, path);
+    if (!Array.isArray(target))
+        return EMPTY;
+    const [prefix, indexStr] = getPrefixAndProp(path);
+    const index = parseInt(indexStr);
+    return [prefix, index];
+}
+export function getArrayIndex(state, path, pathLength) {
+    return getArrayPrefixAndIndex(state, path, pathLength)[1];
+}
+export function getIndexAndEnd(state, path, maxLength) {
+    if (!path)
+        return [];
+    const prop = getPropAfter(path, maxLength);
+    const end = maxLength + prop.length;
+    if (!isArrayPath(path.slice(0, end), state))
+        return [];
+    const index = parseInt(prop);
+    return [index, end];
+}

package/dist/json-patch/utils/pluck.d.ts

@@ -0,0 +1,5 @@
+import type { State } from '../types.js';
+export declare const EMPTY: {};
+export declare function pluck(state: State, keys: string[]): any;
+export declare function pluckWithShallowCopy(state: State, keys: string[], createMissingObjects?: boolean): any;
+export declare function getValue(state: State, value: any, addKey?: string, addValue?: any): any;

package/dist/json-patch/utils/pluck.js

@@ -0,0 +1,30 @@
+import { shallowCopy } from './shallowCopy.js';
+export const EMPTY = {};
+export function pluck(state, keys) {
+    let object = state.root;
+    for (let i = 0, imax = keys.length - 1; i < imax; i++) {
+        const key = keys[i];
+        if (!object[key]) {
+            return null;
+        }
+        object = object[key];
+    }
+    return object;
+}
+export function pluckWithShallowCopy(state, keys, createMissingObjects) {
+    let object = state.root;
+    for (let i = 0, imax = keys.length - 1; i < imax; i++) {
+        const key = keys[i];
+        object = object[key] = createMissingObjects && !object[key] ? getValue(state, EMPTY) : getValue(state, object[key]);
+    }
+    return object;
+}
+export function getValue(state, value, addKey, addValue) {
+    if (!state.cache?.has(value)) {
+        value = shallowCopy(value);
+        state.cache?.add(value);
+    }
+    if (addKey)
+        value[addKey] = addValue;
+    return value;
+}

package/dist/json-patch/utils/shallowCopy.d.ts

@@ -0,0 +1 @@
+export declare function shallowCopy(obj: any): any;

package/dist/json-patch/utils/shallowCopy.js

@@ -0,0 +1,20 @@
+export function shallowCopy(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        const len = obj.length;
+        const ary = new Array(len);
+        for (let i = 0; i < len; i++) {
+            ary[i] = obj[i];
+        }
+        return ary;
+    }
+    const keys = Object.keys(obj);
+    const copy = {};
+    for (let j = 0, jmax = keys.length; j < jmax; j++) {
+        const key = keys[j];
+        copy[key] = obj[key];
+    }
+    return copy;
+}

package/dist/json-patch/utils/softWrites.d.ts

@@ -0,0 +1,7 @@
+import type { JSONPatchOp } from '../types.js';
+export declare function isEmptyObject(value: any): boolean;
+/**
+ * If other objects were added to this same path, assume they are maps/hashes/lookups and don't overwrite, allow
+ * subsequent ops to merge onto the first map created. `soft` will also do this for any value that already exists.
+ */
+export declare function updateSoftWrites(overPath: string, ops: JSONPatchOp[]): JSONPatchOp[];

package/dist/json-patch/utils/softWrites.js

@@ -0,0 +1,18 @@
+import { log } from './log.js';
+import { mapAndFilterOps } from './ops.js';
+export function isEmptyObject(value) {
+    return Boolean(value && typeof value === 'object' && Object.keys(value).length === 0);
+}
+/**
+ * If other objects were added to this same path, assume they are maps/hashes/lookups and don't overwrite, allow
+ * subsequent ops to merge onto the first map created. `soft` will also do this for any value that already exists.
+ */
+export function updateSoftWrites(overPath, ops) {
+    return mapAndFilterOps(ops, op => {
+        if (op.op === 'add' && op.path === overPath && isEmptyObject(op.value)) {
+            log('Removing empty object', op);
+            return null;
+        }
+        return op;
+    });
+}

package/dist/json-patch/utils/toArrayIndex.d.ts

@@ -0,0 +1 @@
+export declare function toArrayIndex(array: any[], str: string): number;

package/dist/json-patch/utils/toArrayIndex.js

@@ -0,0 +1,12 @@
+export function toArrayIndex(array, str) {
+    if (str === '-') {
+        return array.length;
+    }
+    for (let i = 0, imax = str.length; i < imax; i++) {
+        const ch = str.charCodeAt(i);
+        if (57 < ch || ch < 48) {
+            return Infinity;
+        }
+    }
+    return +str;
+}

package/dist/json-patch/utils/toKeys.d.ts

@@ -0,0 +1 @@
+export declare function toKeys(path: string): string[];

package/dist/json-patch/utils/toKeys.js

@@ -0,0 +1,15 @@
+function esc(m) {
+    return m === '~0' ? '~' : '/';
+}
+export function toKeys(path) {
+    const keys = path.split('/');
+    if (!path.includes('~')) {
+        return keys;
+    }
+    for (let i = 0, imax = keys.length; i < imax; i++) {
+        if (keys[i].includes('~')) {
+            keys[i] = keys[i].replace(/~[01]/g, esc);
+        }
+    }
+    return keys;
+}

package/dist/json-patch/utils/updateArrayIndexes.d.ts

@@ -0,0 +1,5 @@
+import type { JSONPatchOp, State } from '../types.js';
+/**
+ * Update array indexes to account for values being added or removed from an array.
+ */
+export declare function updateArrayIndexes(state: State, thisPath: string, otherOps: JSONPatchOp[], modifier: 1 | -1, isRemove?: boolean): JSONPatchOp[];

package/dist/json-patch/utils/updateArrayIndexes.js

@@ -0,0 +1,38 @@
+import { getTypeLike } from './getType.js';
+import { log } from './log.js';
+import { isAdd, mapAndFilterOps, transformRemove } from './ops.js';
+import { getPrefixAndProp } from './paths.js';
+import { updateArrayPath } from './updateArrayPath.js';
+/**
+ * Update array indexes to account for values being added or removed from an array.
+ */
+export function updateArrayIndexes(state, thisPath, otherOps, modifier, isRemove) {
+    const [arrayPrefix, indexStr] = getPrefixAndProp(thisPath);
+    const index = parseInt(indexStr);
+    log('Shifting array indexes', thisPath, modifier);
+    // Check ops for any that need to be replaced
+    return mapAndFilterOps(otherOps, (op, i, breakAfter) => {
+        if (isRemove && thisPath === op.from) {
+            const opLike = getTypeLike(state, op);
+            if (opLike === 'move') {
+                // We need the rest of the otherOps to be adjusted against this "move"
+                breakAfter();
+                return transformRemove(state, op.path, otherOps.slice(i + 1));
+            }
+            else if (opLike === 'copy') {
+                // We need future ops on the copied object to be removed
+                breakAfter();
+                let rest = transformRemove(state, thisPath, otherOps.slice(i + 1));
+                rest = transformRemove(state, op.path, rest);
+                return rest;
+            }
+        }
+        if (op.soft && isAdd(state, op, 'path') && op.path === thisPath) {
+            breakAfter(true);
+            return null;
+        }
+        // check for items from the same array that will be affected
+        op = updateArrayPath(state, op, 'from', arrayPrefix, index, modifier);
+        return op && updateArrayPath(state, op, 'path', arrayPrefix, index, modifier);
+    });
+}

package/dist/json-patch/utils/updateArrayPath.d.ts

@@ -0,0 +1,5 @@
+import type { JSONPatchOp, State } from '../types.js';
+/**
+ * Adjust ops within an array
+ */
+export declare function updateArrayPath(state: State, otherOp: JSONPatchOp, pathName: 'from' | 'path', thisPrefix: string, thisIndex: number, modifier: 1 | -1): JSONPatchOp | [JSONPatchOp, JSONPatchOp] | null;

package/dist/json-patch/utils/updateArrayPath.js

@@ -0,0 +1,45 @@
+import { getTypeLike } from './getType.js';
+import { isAdd } from './ops.js';
+import { getIndexAndEnd } from './paths.js';
+import { getValue } from './pluck.js';
+/**
+ * Adjust ops within an array
+ */
+export function updateArrayPath(state, otherOp, pathName, thisPrefix, thisIndex, modifier) {
+    const path = otherOp[pathName];
+    if (!path || !path.startsWith(thisPrefix))
+        return otherOp;
+    const [otherIndex, end] = getIndexAndEnd(state, path, thisPrefix.length);
+    const opLike = getTypeLike(state, otherOp);
+    // A bit of complex logic to handle moves upwards in an array. Since an item is removed earier in the array and added later, the other index is like it was one less (or this index was one more), so we correct it
+    if (opLike === 'move' &&
+        pathName === 'path' &&
+        otherOp.from?.startsWith(thisPrefix) &&
+        getIndexAndEnd(state, otherOp.from, thisPrefix.length)[0] < otherIndex) {
+        thisIndex -= 1;
+    }
+    if (otherIndex < thisIndex)
+        return otherOp;
+    // When this is a removed item and the op is a subpath or a non-add, remove it.
+    if (otherIndex === thisIndex && modifier === -1) {
+        if (end === path.length) {
+            // If we are adding to the location something got removed, continue adding it.
+            if (isAdd(state, otherOp, pathName))
+                return otherOp;
+            if (otherOp.op === 'replace')
+                return getValue(state, otherOp, 'op', 'add');
+            // If we are replacing an item which was removed, add it (don't replace something else in the array)
+            if (opLike === 'replace')
+                return [{ op: 'add', path: otherOp.path, value: null }, otherOp];
+        }
+        return null;
+    }
+    else if (isAdd(state, otherOp, pathName) && otherIndex === thisIndex && end === path.length) {
+        if (otherOp.soft)
+            return null;
+        return otherOp;
+    }
+    const newPath = thisPrefix + (otherIndex + modifier) + path.slice(end);
+    otherOp = getValue(state, otherOp, pathName, newPath);
+    return otherOp;
+}

package/dist/net/AbstractTransport.d.ts

@@ -0,0 +1,47 @@
+import type { ConnectionState, Transport } from '../net/protocol/types.js';
+/**
+ * Abstract base class that implements common functionality for various transport implementations.
+ * Provides state management and event signaling for connection state changes and message reception.
+ * Concrete transport implementations must extend this class and implement the abstract methods.
+ */
+export declare abstract class AbstractTransport implements Transport {
+    private _state;
+    /**
+     * Signal that emits when the connection state changes.
+     * Subscribers will receive the new connection state as an argument.
+     */
+    readonly onStateChange: import("../event-signal.js").Signal<(state: ConnectionState) => void>;
+    /**
+     * Signal that emits when a message is received from the transport.
+     * Subscribers will receive the message data as a string.
+     */
+    readonly onMessage: import("../event-signal.js").Signal<(data: string) => void>;
+    /**
+     * Gets the current connection state of the transport.
+     * @returns The current connection state ('connecting', 'connected', 'disconnected', or 'error')
+     */
+    get state(): ConnectionState;
+    /**
+     * Sets the connection state and emits a state change event.
+     * This method is protected and should only be called by subclasses.
+     * @param state - The new connection state
+     */
+    protected set state(state: ConnectionState);
+    /**
+     * Establishes the connection for this transport.
+     * Must be implemented by concrete subclasses.
+     * @returns A promise that resolves when the connection is established
+     */
+    abstract connect(): Promise<void>;
+    /**
+     * Terminates the connection for this transport.
+     * Must be implemented by concrete subclasses.
+     */
+    abstract disconnect(): void;
+    /**
+     * Sends data through this transport.
+     * Must be implemented by concrete subclasses.
+     * @param data - The string data to send
+     */
+    abstract send(data: string): void;
+}