@fluidframework/legacy-dds 2.50.0-345060

package/src/array/sharedArrayFactory.ts

@@ -0,0 +1,88 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type {
+	IChannelServices,
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	IChannelFactory,
+} from "@fluidframework/datastore-definitions/internal";
+import {
+	createSharedObjectKind,
+	type ISharedObjectKind,
+	type SharedObjectKind,
+} from "@fluidframework/shared-object-base/internal";
+
+import { pkgVersion } from "../packageVersion.js";
+
+import type { ISharedArray, SerializableTypeForSharedArray } from "./interfaces.js";
+import { SharedArrayClass } from "./sharedArray.js";
+
+/**
+ * @internal
+ */
+export class SharedArrayFactory<T extends SerializableTypeForSharedArray>
+	implements IChannelFactory
+{
+	public static readonly Type = "https://graph.microsoft.com/types/SharedArray";
+
+	public static readonly Attributes: IChannelAttributes = {
+		type: SharedArrayFactory.Type,
+		snapshotFormatVersion: "0.1",
+		packageVersion: pkgVersion,
+	};
+
+	public get type(): string {
+		return SharedArrayFactory.Type;
+	}
+
+	public get attributes(): IChannelAttributes {
+		return SharedArrayFactory.Attributes;
+	}
+
+	public async load(
+		runtime: IFluidDataStoreRuntime,
+		id: string,
+		services: IChannelServices,
+		attributes: IChannelAttributes,
+	): Promise<ISharedArray<T>> {
+		/**
+		 * * The SharedArray
+		 */
+		const sharedArray = new SharedArrayClass<T>(id, runtime, attributes);
+		await sharedArray.load(services);
+		return sharedArray;
+	}
+
+	public create(document: IFluidDataStoreRuntime, id: string): ISharedArray<T> {
+		/**
+		 * * The SharedArray
+		 */
+		const sharedArray = new SharedArrayClass<T>(id, document, this.attributes);
+		sharedArray.initializeLocal();
+		return sharedArray;
+	}
+}
+
+/**
+ * Entrypoint for {@link ISharedArray} creation.
+ * @legacy
+ * @alpha
+ */
+export const SharedArray: ISharedObjectKind<ISharedArray<SerializableTypeForSharedArray>> &
+	SharedObjectKind<ISharedArray<SerializableTypeForSharedArray>> =
+	createSharedObjectKind<ISharedArray<SerializableTypeForSharedArray>>(SharedArrayFactory);
+
+/**
+ * Entrypoint for {@link ISharedArray} creation.
+ * @legacy
+ * @alpha
+ */
+export const SharedArrayBuilder = <
+	T extends SerializableTypeForSharedArray,
+>(): ISharedObjectKind<ISharedArray<T>> & SharedObjectKind<ISharedArray<T>> => {
+	const factory = SharedArrayFactory<T>;
+	return createSharedObjectKind<ISharedArray<T>>(factory);
+};

package/src/array/sharedArrayOperations.ts

@@ -0,0 +1,89 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * @legacy
+ * @alpha
+ */
+export const OperationType = {
+	insertEntry: 0,
+	deleteEntry: 1,
+	moveEntry: 2,
+	toggle: 3,
+	toggleMove: 4,
+} as const;
+
+/**
+ * @legacy
+ * @alpha
+ */
+export type OperationType = (typeof OperationType)[keyof typeof OperationType];
+
+/**
+ * @legacy
+ * @alpha
+ */
+export interface IInsertOperation<T = unknown> {
+	type: typeof OperationType.insertEntry;
+	entryId: string;
+	value: T;
+	insertAfterEntryId?: string;
+}
+
+/**
+ * @legacy
+ * @alpha
+ */
+export interface IDeleteOperation {
+	type: typeof OperationType.deleteEntry;
+	entryId: string;
+}
+
+/**
+ * @legacy
+ * @alpha
+ */
+export interface IMoveOperation {
+	type: typeof OperationType.moveEntry;
+	entryId: string;
+	insertAfterEntryId?: string;
+	changedToEntryId: string;
+}
+
+/**
+ * @legacy
+ * @alpha
+ */
+export interface IToggleOperation {
+	type: typeof OperationType.toggle;
+	entryId: string;
+	isDeleted: boolean;
+}
+
+/**
+ * @legacy
+ * @alpha
+ */
+export interface IToggleMoveOperation {
+	type: typeof OperationType.toggleMove;
+	entryId: string;
+	changedToEntryId: string;
+}
+
+/**
+ * @legacy
+ * @alpha
+ */
+export type ISharedArrayRevertibleOperation = IToggleOperation | IToggleMoveOperation;
+
+/**
+ * @legacy
+ * @alpha
+ */
+export type ISharedArrayOperation<T = unknown> =
+	| IInsertOperation<T>
+	| IDeleteOperation
+	| IMoveOperation
+	| ISharedArrayRevertibleOperation;

package/src/array/sharedArrayRevertible.ts

@@ -0,0 +1,50 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { ISharedArrayRevertible, IRevertible } from "./interfaces.js";
+import type { ISharedArrayOperation } from "./sharedArrayOperations.js";
+import { OperationType } from "./sharedArrayOperations.js";
+
+/**
+ * @internal
+ */
+export class SharedArrayRevertible implements IRevertible {
+	private readonly sharedArray: ISharedArrayRevertible;
+	private readonly op: ISharedArrayOperation;
+	public constructor(sharedArray: ISharedArrayRevertible, op: ISharedArrayOperation) {
+		this.sharedArray = sharedArray;
+		this.op = op;
+	}
+
+	public revert(): void {
+		switch (this.op.type) {
+			case OperationType.insertEntry: {
+				this.sharedArray.toggle(this.op.entryId);
+				break;
+			}
+			case OperationType.deleteEntry: {
+				this.sharedArray.toggle(this.op.entryId);
+				break;
+			}
+			case OperationType.toggle: {
+				this.sharedArray.toggle(this.op.entryId);
+				break;
+			}
+			case OperationType.moveEntry: {
+				this.sharedArray.toggleMove(this.op.entryId, this.op.changedToEntryId);
+				break;
+			}
+			case OperationType.toggleMove: {
+				this.sharedArray.toggleMove(this.op.changedToEntryId, this.op.entryId);
+				break;
+			}
+			default: {
+				throw new Error(`Unknown operation type`);
+			}
+		}
+	}
+
+	public dispose(): void {}
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export type {
+	SerializableTypeForSharedSignal,
+	ISharedSignal,
+	ISharedSignalEvents,
+	ISignalOperation,
+} from "./signal/index.js";
+export { SharedSignal } from "./signal/index.js";
+export { SharedSignalFactory } from "./signal/index.js";
+export { SharedArray, SharedArrayBuilder, OperationType } from "./array/index.js";
+export { SharedArrayFactory } from "./array/index.js";
+export { SharedArrayRevertible } from "./array/index.js";
+export type {
+	SerializableTypeForSharedArray,
+	ISharedArray,
+	ISharedArrayEvents,
+	ISharedArrayRevertible,
+} from "./array/index.js";
+export type {
+	ISharedArrayOperation,
+	IDeleteOperation,
+	IInsertOperation,
+	IMoveOperation,
+	ISharedArrayRevertibleOperation,
+	IToggleMoveOperation,
+	IToggleOperation,
+} from "./array/index.js";
+export type { IRevertible } from "./array/index.js";

package/src/packageVersion.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ *
+ * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY
+ */
+
+export const pkgName = "@fluidframework/legacy-dds";
+export const pkgVersion = "2.50.0-345060";

package/src/signal/README.md

@@ -0,0 +1,25 @@
+# @SharedSignal
+
+## SharedSignal
+
+A DDS created by Loop which we now take ownership. Following README content is provided by them. Last commit in the office bohemia repo before migrating: 8854bfbeb077433015c93de582d0eefa2c657fa7
+
+The SharedSignal distributed data structure is used to handle local, remote ops and offline scenarios. Transactions are set up using this DDS to generate marker op. Example [DDS1 OP -> DDS2 OP -> DDS3 OP -> Shared Signal DDS op]
+
+### Creation
+
+To create a `SharedSignal`, call the static create method:
+
+```typescript
+
+const mySignal = SharedSignal.create(this.runtime, id);
+
+```
+
+#### `.notify()`
+
+Used for generating a signal
+
+### `.processCore()`
+
+Used for processing a shared signal operation.

package/src/signal/index.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export type {
+	SerializableTypeForSharedSignal,
+	ISharedSignal,
+	ISharedSignalEvents,
+	ISignalOperation,
+} from "./interfaces.js";
+export { SharedSignalFactory, SharedSignal } from "./sharedSignalFactory.js";

package/src/signal/interfaces.ts

@@ -0,0 +1,53 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
+import type {
+	ISharedObject,
+	ISharedObjectEvents,
+} from "@fluidframework/shared-object-base/internal";
+
+/**
+ * Basic types for the SharedSignal DDS
+ * It can be used as a generic constraint (`extends SerializableTypeForSharedSignal`) but is
+ * *never* meant to be a concrete/real type on its own.
+ * @legacy
+ * @alpha
+ */
+export type SerializableTypeForSharedSignal =
+	| boolean
+	| number
+	| string
+	| IFluidHandle
+	| object;
+
+/**
+ * @legacy
+ * @alpha
+ */
+export interface ISharedSignalEvents<T extends SerializableTypeForSharedSignal>
+	extends ISharedObjectEvents {
+	/* eslint-disable-next-line @typescript-eslint/no-explicit-any
+-- TODO: Using 'any' type defeats the purpose of TypeScript. Consider replacing it with a concrete type, or 'unknown'. */
+	(event: "notify", listener: (value: T, isLocal: boolean) => void): any;
+}
+
+/**
+ * @legacy
+ * @alpha
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface ISharedSignal<T extends SerializableTypeForSharedSignal = any>
+	extends ISharedObject<ISharedSignalEvents<T>> {
+	notify(metadata?: T): void;
+}
+
+/**
+ * @internal
+ */
+export interface ISignalOperation<out T = unknown> {
+	type: "signal";
+	readonly metadata?: T;
+}

package/src/signal/sharedSignal.ts

@@ -0,0 +1,169 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type {
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	IChannelStorageService,
+	IChannelFactory,
+} from "@fluidframework/datastore-definitions/internal";
+import { FileMode, MessageType, TreeEntry } from "@fluidframework/driver-definitions/internal";
+import type {
+	ISequencedDocumentMessage,
+	ITree,
+} from "@fluidframework/driver-definitions/internal";
+import type { ISummaryTreeWithStats } from "@fluidframework/runtime-definitions/internal";
+import { convertToSummaryTreeWithStats } from "@fluidframework/runtime-utils/internal";
+import type { IFluidSerializer } from "@fluidframework/shared-object-base/internal";
+import { SharedObject } from "@fluidframework/shared-object-base/internal";
+
+import type {
+	ISharedSignal,
+	ISharedSignalEvents,
+	ISignalOperation,
+	SerializableTypeForSharedSignal,
+} from "./interfaces.js";
+import { SharedSignalFactory } from "./sharedSignalFactory.js";
+
+const snapshotFileName = "header";
+
+/**
+ * Represents a shared signal that allows communication between distributed clients.
+ *
+ * @internal
+ */
+export class SharedSignalClass<T extends SerializableTypeForSharedSignal = any>
+	extends SharedObject<ISharedSignalEvents<T>>
+	implements ISharedSignal<T>
+{
+	/**
+	 * Create a new shared signal
+	 *
+	 * @param runtime - data store runtime the new shared signal belongs to
+	 * @param id - optional name of the shared signal
+	 * @returns newly create shared signal (but not attached yet)
+	 */
+	public static create(runtime: IFluidDataStoreRuntime, id?: string): SharedSignalClass {
+		return runtime.createChannel(id, SharedSignalFactory.Type) as SharedSignalClass;
+	}
+
+	/**
+	 * Get a factory for SharedSignal to register with the data store.
+	 *
+	 * @returns a factory that creates and load SharedSignal
+	 */
+	public static getFactory(): IChannelFactory {
+		return new SharedSignalFactory();
+	}
+
+	/**
+	 * Constructs a new shared signal. If the object is non-local an id and service interfaces will
+	 * be provided
+	 * @param id - optional name of the shared signal
+	 * @param runtime - data store runtime the shared signal belongs to
+	 * @param attributes - represents the attributes of a channel/DDS.
+	 */
+	public constructor(
+		id: string,
+		runtime: IFluidDataStoreRuntime,
+		attributes: IChannelAttributes,
+	) {
+		super(id, runtime, attributes, "loop_sharedSignal_" /* telemetryContextPrefix */);
+	}
+
+	/**
+	 * Method used for generating a signal.
+	 */
+	public notify(metadata?: T): void {
+		// If we are not attached, don't submit the op.
+		if (!this.isAttached()) {
+			return;
+		}
+
+		const op: ISignalOperation<T> = {
+			type: "signal",
+			metadata,
+		};
+
+		this.notifyCore(op, true);
+
+		this.submitLocalMessage(op);
+	}
+
+	protected summarizeCore(_serializer: IFluidSerializer): ISummaryTreeWithStats {
+		const tree: ITree = {
+			entries: [
+				{
+					mode: FileMode.File,
+					path: snapshotFileName,
+					type: TreeEntry[TreeEntry.Blob],
+					value: {
+						contents: JSON.stringify(""),
+						// eslint-disable-next-line unicorn/text-encoding-identifier-case
+						encoding: "utf-8",
+					},
+				},
+			],
+		};
+
+		const summaryTreeWithStats = convertToSummaryTreeWithStats(tree);
+
+		return summaryTreeWithStats;
+	}
+
+	/**
+	 * Load share signal from snapshot
+	 *
+	 * @param _storage - the storage to get the snapshot from
+	 * @returns - promise that resolved when the load is completed
+	 */
+	protected async loadCore(_storage: IChannelStorageService): Promise<void> {}
+
+	protected override initializeLocalCore(): void {}
+
+	/**
+	 * Callback on disconnect
+	 */
+	protected onDisconnect(): void {}
+
+	/**
+	 * Process a shared signal operation
+	 *
+	 * @param message - the message to prepare
+	 * @param local - whether the message was sent by the local client
+	 * @param _localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+	 * For messages from a remote client, this will be undefined.
+	 */
+	protected processCore(
+		message: ISequencedDocumentMessage,
+		local: boolean,
+		_localOpMetadata: unknown,
+	): void {
+		if ((message.type as MessageType) === MessageType.Operation && !local) {
+			const op = message.contents as ISignalOperation<T>;
+
+			switch (op.type) {
+				case "signal": {
+					this.notifyCore(op, local);
+					break;
+				}
+
+				default: {
+					throw new Error("Unknown operation");
+				}
+			}
+		}
+	}
+
+	private notifyCore(op: ISignalOperation<T>, isLocal: boolean): void {
+		this.emit("notify", op.metadata, isLocal);
+	}
+
+	protected applyStashedOp(_content: unknown): void {
+		throw new Error("Not implemented");
+	}
+}

package/src/signal/sharedSignalFactory.ts

@@ -0,0 +1,62 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type {
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	IChannelFactory,
+	IChannelServices,
+} from "@fluidframework/datastore-definitions/internal";
+import { createSharedObjectKind } from "@fluidframework/shared-object-base/internal";
+
+import { pkgVersion } from "../packageVersion.js";
+
+import type { ISharedSignal } from "./interfaces.js";
+import { SharedSignalClass } from "./sharedSignal.js";
+
+/**
+ * @internal
+ */
+export class SharedSignalFactory implements IChannelFactory<ISharedSignal> {
+	public static readonly Type: string = "https://graph.microsoft.com/types/signal";
+
+	public static readonly Attributes: IChannelAttributes = {
+		type: SharedSignalFactory.Type,
+		snapshotFormatVersion: "0.1",
+		packageVersion: pkgVersion,
+	};
+
+	public get type(): string {
+		return SharedSignalFactory.Type;
+	}
+
+	public get attributes(): IChannelAttributes {
+		return SharedSignalFactory.Attributes;
+	}
+
+	public async load(
+		runtime: IFluidDataStoreRuntime,
+		id: string,
+		services: IChannelServices,
+		attributes: IChannelAttributes,
+	): Promise<ISharedSignal> {
+		const signal = new SharedSignalClass(id, runtime, attributes);
+		await signal.load(services);
+		return signal;
+	}
+
+	public create(document: IFluidDataStoreRuntime, id: string): ISharedSignal {
+		const signal = new SharedSignalClass(id, document, this.attributes);
+		signal.initializeLocal();
+		return signal;
+	}
+}
+
+/**
+ * Entrypoint for {@link ISharedSignal} creation.
+ * @legacy
+ * @alpha
+ */
+export const SharedSignal = createSharedObjectKind<ISharedSignal>(SharedSignalFactory);

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+	// This config must be used in a "type": "commonjs" environment. (Use fluid-tsc commonjs.)
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+	},
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+	"extends": "../../../common/build/build-common/tsconfig.node16.json",
+	"include": ["src/**/*"],
+	"exclude": ["src/test/**/*"],
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./lib",
+		"exactOptionalPropertyTypes": false,
+	},
+}

package/tsdoc.json

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+	"extends": ["../../../common/build/build-common/tsdoc-base.json"]
+}