@fluidframework/sequence 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/intervalTree.ts

@@ -4,18 +4,18 @@
  */
 
 import {
-    IIntegerRange,
-    RBNode,
-    IRBAugmentation,
-    IRBMatcher,
-    RedBlackTree,
-    ConflictAction,
-    RBNodeActions,
+	IIntegerRange,
+	RBNode,
+	IRBAugmentation,
+	IRBMatcher,
+	RedBlackTree,
+	ConflictAction,
+	RBNodeActions,
 } from "@fluidframework/merge-tree";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 
 export interface AugmentedIntervalNode {
-    minmax: IInterval;
+	minmax: IInterval;
 }
 
 export const integerRangeToString = (range: IIntegerRange) => `[${range.start},${range.end})`;
@@ -24,53 +24,53 @@ export const integerRangeToString = (range: IIntegerRange) => `[${range.start},$
  * Basic interval abstraction
  */
 export interface IInterval {
-    /**
-     * @returns a new interval object with identical semantics.
-     */
-    clone(): IInterval;
-    /**
-     * Compares this interval to `b` with standard comparator semantics:
-     * - returns -1 if this is less than `b`
-     * - returns 1 if this is greater than `b`
-     * - returns 0 if this is equivalent to `b`
-     * @param b - Interval to compare against
-     */
-    compare(b: IInterval): number;
-    /**
-     * Compares the start endpoint of this interval to `b`'s start endpoint.
-     * Standard comparator semantics apply.
-     * @param b - Interval to compare against
-     */
-    compareStart(b: IInterval): number;
-    /**
-     * Compares the end endpoint of this interval to `b`'s end endpoint.
-     * Standard comparator semantics apply.
-     * @param b - Interval to compare against
-     */
-    compareEnd(b: IInterval): number;
-    /**
-     * Modifies one or more of the endpoints of this interval, returning a new interval representing the result.
-     * @internal
-     */
-    modify(
-        label: string,
-        start: number | undefined,
-        end: number | undefined,
-        op?: ISequencedDocumentMessage,
-        localSeq?: number
-    ): IInterval | undefined;
-    /**
-     * @returns whether this interval overlaps with `b`.
-     * Since intervals are inclusive, this includes cases where endpoints are equal.
-     */
-    overlaps(b: IInterval): boolean;
-    /**
-     * Unions this interval with `b`, returning a new interval.
-     * The union operates as a convex hull, i.e. if the two intervals are disjoint, the return value includes
-     * intermediate values between the two intervals.
-     * @internal
-     */
-    union(b: IInterval): IInterval;
+	/**
+	 * @returns a new interval object with identical semantics.
+	 */
+	clone(): IInterval;
+	/**
+	 * Compares this interval to `b` with standard comparator semantics:
+	 * - returns -1 if this is less than `b`
+	 * - returns 1 if this is greater than `b`
+	 * - returns 0 if this is equivalent to `b`
+	 * @param b - Interval to compare against
+	 */
+	compare(b: IInterval): number;
+	/**
+	 * Compares the start endpoint of this interval to `b`'s start endpoint.
+	 * Standard comparator semantics apply.
+	 * @param b - Interval to compare against
+	 */
+	compareStart(b: IInterval): number;
+	/**
+	 * Compares the end endpoint of this interval to `b`'s end endpoint.
+	 * Standard comparator semantics apply.
+	 * @param b - Interval to compare against
+	 */
+	compareEnd(b: IInterval): number;
+	/**
+	 * Modifies one or more of the endpoints of this interval, returning a new interval representing the result.
+	 * @internal
+	 */
+	modify(
+		label: string,
+		start: number | undefined,
+		end: number | undefined,
+		op?: ISequencedDocumentMessage,
+		localSeq?: number,
+	): IInterval | undefined;
+	/**
+	 * @returns whether this interval overlaps with `b`.
+	 * Since intervals are inclusive, this includes cases where endpoints are equal.
+	 */
+	overlaps(b: IInterval): boolean;
+	/**
+	 * Unions this interval with `b`, returning a new interval.
+	 * The union operates as a convex hull, i.e. if the two intervals are disjoint, the return value includes
+	 * intermediate values between the two intervals.
+	 * @internal
+	 */
+	union(b: IInterval): IInterval;
 }
 
 const intervalComparer = (a: IInterval, b: IInterval) => a.compare(b);
@@ -79,88 +79,88 @@ export type IntervalNode<T extends IInterval> = RBNode<T, AugmentedIntervalNode>
 
 export type IntervalConflictResolver<TInterval> = (a: TInterval, b: TInterval) => TInterval;
 
-export class IntervalTree<T extends IInterval> implements IRBAugmentation<T, AugmentedIntervalNode>,
-    IRBMatcher<T, AugmentedIntervalNode> {
-    public intervals = new RedBlackTree<T, AugmentedIntervalNode>(intervalComparer, this);
-
-    public remove(x: T) {
-        this.intervals.remove(x);
-    }
-
-    public removeExisting(x: T) {
-        this.intervals.removeExisting(x);
-    }
-
-    public put(x: T, conflict?: IntervalConflictResolver<T>) {
-        let rbConflict: ConflictAction<T, AugmentedIntervalNode> | undefined;
-        if (conflict) {
-            rbConflict = (key: T, currentKey: T) => {
-                const ival = conflict(key, currentKey);
-                return {
-                    key: ival,
-                };
-            };
-        }
-        this.intervals.put(x, { minmax: x.clone() }, rbConflict);
-    }
-
-    public map(fn: (x: T) => void) {
-        const actions: RBNodeActions<T, AugmentedIntervalNode> = {
-            infix: (node) => {
-                fn(node.key);
-                return true;
-            },
-            showStructure: true,
-        };
-        this.intervals.walk(actions);
-    }
-
-    public mapUntil(fn: (X: T) => boolean) {
-        const actions: RBNodeActions<T, AugmentedIntervalNode> = {
-            infix: (node) => {
-                return fn(node.key);
-            },
-            showStructure: true,
-        };
-        this.intervals.walk(actions);
-    }
-
-    public mapBackward(fn: (x: T) => void) {
-        const actions: RBNodeActions<T, AugmentedIntervalNode> = {
-            infix: (node) => {
-                fn(node.key);
-                return true;
-            },
-            showStructure: true,
-        };
-        this.intervals.walkBackward(actions);
-    }
-
-    // TODO: toString()
-    public match(x: T) {
-        return this.intervals.gather(x, this);
-    }
-
-    public matchNode(node: IntervalNode<T> | undefined, key: T) {
-        return !!node && node.key.overlaps(key);
-    }
-
-    public continueSubtree(node: IntervalNode<T> | undefined, key: T) {
-        return !!node && node.data.minmax.overlaps(key);
-    }
-
-    public update(node: IntervalNode<T>) {
-        if (node.left && node.right) {
-            node.data.minmax = node.key.union(
-                node.left.data.minmax.union(node.right.data.minmax));
-        } else {
-            if (node.left) {
-                node.data.minmax = node.key.union(node.left.data.minmax);
-            } else if (node.right) {
-                node.data.minmax = node.key.union(node.right.data.minmax);
-            } else {
-                node.data.minmax = node.key.clone();
-            }
-        }
-    }
+export class IntervalTree<T extends IInterval>
+	implements IRBAugmentation<T, AugmentedIntervalNode>, IRBMatcher<T, AugmentedIntervalNode>
+{
+	public intervals = new RedBlackTree<T, AugmentedIntervalNode>(intervalComparer, this);
+
+	public remove(x: T) {
+		this.intervals.remove(x);
+	}
+
+	public removeExisting(x: T) {
+		this.intervals.removeExisting(x);
+	}
+
+	public put(x: T, conflict?: IntervalConflictResolver<T>) {
+		let rbConflict: ConflictAction<T, AugmentedIntervalNode> | undefined;
+		if (conflict) {
+			rbConflict = (key: T, currentKey: T) => {
+				const ival = conflict(key, currentKey);
+				return {
+					key: ival,
+				};
+			};
+		}
+		this.intervals.put(x, { minmax: x.clone() }, rbConflict);
+	}
+
+	public map(fn: (x: T) => void) {
+		const actions: RBNodeActions<T, AugmentedIntervalNode> = {
+			infix: (node) => {
+				fn(node.key);
+				return true;
+			},
+			showStructure: true,
+		};
+		this.intervals.walk(actions);
+	}
+
+	public mapUntil(fn: (X: T) => boolean) {
+		const actions: RBNodeActions<T, AugmentedIntervalNode> = {
+			infix: (node) => {
+				return fn(node.key);
+			},
+			showStructure: true,
+		};
+		this.intervals.walk(actions);
+	}
+
+	public mapBackward(fn: (x: T) => void) {
+		const actions: RBNodeActions<T, AugmentedIntervalNode> = {
+			infix: (node) => {
+				fn(node.key);
+				return true;
+			},
+			showStructure: true,
+		};
+		this.intervals.walkBackward(actions);
+	}
+
+	// TODO: toString()
+	public match(x: T) {
+		return this.intervals.gather(x, this);
+	}
+
+	public matchNode(node: IntervalNode<T> | undefined, key: T) {
+		return !!node && node.key.overlaps(key);
+	}
+
+	public continueSubtree(node: IntervalNode<T> | undefined, key: T) {
+		return !!node && node.data.minmax.overlaps(key);
+	}
+
+	public update(node: IntervalNode<T>) {
+		if (node.left && node.right) {
+			node.data.minmax = node.key.union(node.left.data.minmax.union(node.right.data.minmax));
+		} else {
+			if (node.left) {
+				node.data.minmax = node.key.union(node.left.data.minmax);
+			} else if (node.right) {
+				node.data.minmax = node.key.union(node.right.data.minmax);
+			} else {
+				node.data.minmax = node.key.clone();
+			}
+		}
+	}
 }

package/src/localValues.ts

@@ -4,52 +4,47 @@
  */
 
 import { IFluidHandle } from "@fluidframework/core-interfaces";
+import { IFluidSerializer, serializeHandles } from "@fluidframework/shared-object-base";
 import {
-    IFluidSerializer,
-    serializeHandles,
-} from "@fluidframework/shared-object-base";
-import {
-    ISerializableValue,
-    ISerializedValue,
-    IValueOperation,
-    IValueType,
+	ISerializableValue,
+	ISerializedValue,
+	IValueOperation,
+	IValueType,
 } from "./defaultMapInterfaces";
 
 /**
  * A local value to be stored in a container type DDS.
  */
 export interface ILocalValue<T = any> {
-    /**
-     * Type indicator of the value stored within.
-     */
-    readonly type: string;
+	/**
+	 * Type indicator of the value stored within.
+	 */
+	readonly type: string;
 
-    /**
-     * The in-memory value stored within.
-     */
-    readonly value: T;
+	/**
+	 * The in-memory value stored within.
+	 */
+	readonly value: T;
 
-    /**
-     * Retrieve the serialized form of the value stored within.
-     * @param serializer - Data store runtime's serializer
-     * @param bind - Container type's handle
-     * @returns The serialized form of the contained value
-     */
-    makeSerialized(
-        serializer: IFluidSerializer,
-        bind: IFluidHandle,
-    ): ISerializedValue;
+	/**
+	 * Retrieve the serialized form of the value stored within.
+	 * @param serializer - Data store runtime's serializer
+	 * @param bind - Container type's handle
+	 * @returns The serialized form of the contained value
+	 */
+	makeSerialized(serializer: IFluidSerializer, bind: IFluidHandle): ISerializedValue;
 }
 
 export function makeSerializable(
-    localValue: ILocalValue,
-    serializer: IFluidSerializer,
-    bind: IFluidHandle): ISerializableValue {
-    const value = localValue.makeSerialized(serializer, bind);
-    return {
-        type: value.type,
-        value: value.value && JSON.parse(value.value),
-    };
+	localValue: ILocalValue,
+	serializer: IFluidSerializer,
+	bind: IFluidHandle,
+): ISerializableValue {
+	const value = localValue.makeSerialized(serializer, bind);
+	return {
+		type: value.type,
+		value: value.value && JSON.parse(value.value),
+	};
 }
 
 /**
@@ -58,48 +53,44 @@ export function makeSerializable(
  * @alpha
  */
 export class ValueTypeLocalValue<T> implements ILocalValue<T> {
-    /**
-     * Create a new ValueTypeLocalValue.
-     * @param value - The instance of the value type stored within
-     * @param valueType - The type object of the value type stored within
-     */
-    constructor(public readonly value: T, private readonly valueType: IValueType<T>) {
-    }
+	/**
+	 * Create a new ValueTypeLocalValue.
+	 * @param value - The instance of the value type stored within
+	 * @param valueType - The type object of the value type stored within
+	 */
+	constructor(public readonly value: T, private readonly valueType: IValueType<T>) {}
 
-    /**
-     * {@inheritDoc ILocalValue."type"}
-     */
-    public get type(): string {
-        return this.valueType.name;
-    }
+	/**
+	 * {@inheritDoc ILocalValue."type"}
+	 */
+	public get type(): string {
+		return this.valueType.name;
+	}
 
-    /**
-     * {@inheritDoc ILocalValue.makeSerialized}
-     */
-    public makeSerialized(
-        serializer: IFluidSerializer,
-        bind: IFluidHandle,
-    ): ISerializedValue {
-        const storedValueType = this.valueType.factory.store(this.value);
-        const value = serializeHandles(storedValueType, serializer, bind);
+	/**
+	 * {@inheritDoc ILocalValue.makeSerialized}
+	 */
+	public makeSerialized(serializer: IFluidSerializer, bind: IFluidHandle): ISerializedValue {
+		const storedValueType = this.valueType.factory.store(this.value);
+		const value = serializeHandles(storedValueType, serializer, bind);
 
-        return {
-            type: this.type,
-            value,
-        };
-    }
+		return {
+			type: this.type,
+			value,
+		};
+	}
 
-    /**
-     * Get the handler for a given op of this value type.
-     * @param opName - The name of the operation that needs processing
-     * @returns The object which can process the given op
-     */
-    public getOpHandler(opName: string): IValueOperation<T> {
-        const handler = this.valueType.ops.get(opName);
-        if (!handler) {
-            throw new Error("Unknown type message");
-        }
+	/**
+	 * Get the handler for a given op of this value type.
+	 * @param opName - The name of the operation that needs processing
+	 * @returns The object which can process the given op
+	 */
+	public getOpHandler(opName: string): IValueOperation<T> {
+		const handler = this.valueType.ops.get(opName);
+		if (!handler) {
+			throw new Error("Unknown type message");
+		}
 
-        return handler;
-    }
+		return handler;
+	}
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/sequence";
-export const pkgVersion = "2.0.0-internal.3.0.2";
+export const pkgVersion = "2.0.0-internal.3.2.0";