@fluidframework/odsp-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/src/WriteBufferUtils.ts

@@ -3,17 +3,16 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/common-utils";
-import { ReadBuffer } from "./ReadBufferUtils";
+import { IsoBuffer } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-utils";
 import {
-    BlobCore,
-    codeToBytesMap,
-    getValueSafely,
-    MarkerCodes,
-    MarkerCodesEnd,
-    MarkerCodesStart,
-    NodeCore,
-    TreeBuilder,
+	BlobCore,
+	codeToBytesMap,
+	getValueSafely,
+	MarkerCodes,
+	MarkerCodesEnd,
+	MarkerCodesStart,
+	NodeCore,
 } from "./zipItDataRepresentationUtils";
 
 /**
@@ -21,100 +20,99 @@ import {
  * Used by tree code to serialize tree into binary representation.
  */
 export class WriteBuffer {
-    protected data?: Uint8Array = new Uint8Array(4096);
-    protected index = 0;
+	protected data?: Uint8Array = new Uint8Array(4096);
+	protected index = 0;
 
-    protected push(code: number) {
-        assert(this.data !== undefined, 0x225 /* "Data should be there" */);
-        const length = this.data.length;
-        if (this.index === length) {
-            const newData = new Uint8Array(length * 1.2 + 4096);
-            let index = 0;
-            const oldData = this.data;
-            while (index < length) {
-                newData[index] = oldData[index];
-                index++;
-            }
-            this.data = newData;
-        }
-        this.data[this.index] = code % 256;
-        this.index++;
-    }
+	protected push(code: number) {
+		assert(this.data !== undefined, 0x225 /* "Data should be there" */);
+		const length = this.data.length;
+		if (this.index === length) {
+			const newData = new Uint8Array(length * 1.2 + 4096);
+			let index = 0;
+			const oldData = this.data;
+			while (index < length) {
+				newData[index] = oldData[index];
+				index++;
+			}
+			this.data = newData;
+		}
+		this.data[this.index] = code % 256;
+		this.index++;
+	}
 
-    public write(codeArg: number, lengthArg = 1) {
-        let code = codeArg;
-        let length = lengthArg;
-        while (length > 0) {
-            this.push(code % 256);
-            code = Math.floor(code / 256);
-            length--;
-        }
-        assert(code === 0, 0x226 /* Should write complete data */);
-    }
+	public write(codeArg: number, lengthArg = 1) {
+		let code = codeArg;
+		let length = lengthArg;
+		while (length > 0) {
+			this.push(code % 256);
+			code = Math.floor(code / 256);
+			length--;
+		}
+		assert(code === 0, 0x226 /* Should write complete data */);
+	}
 
-    public done(): ReadBuffer {
-        assert(this.data !== undefined, 0x227 /* "Data should be there" */);
-        // We can slice it to have smaller memory representation.
-        // But it will be way more expensive in terms of CPU cycles!
-        const buffer = new ReadBuffer(this.data.subarray(0, this.index));
-        this.data = undefined;
-        return buffer;
-    }
+	public done(): Uint8Array {
+		assert(this.data !== undefined, 0x227 /* "Data should be there" */);
+		// We can slice it to have smaller memory representation.
+		// But it will be way more expensive in terms of CPU cycles!
+		const buffer = this.data.subarray(0, this.index);
+		this.data = undefined;
+		return buffer;
+	}
 }
 
 // This list of maps below is reverse mapping of Marker Codes specified in zipItDataRepresentationUtils.ts file.
 // We can also found them on server filestore code.
-// eslint-disable-next-line max-len
 // https://onedrive.visualstudio.com/SharePoint%20Online/_git/SPO?path=/cobalt/Base/Property/BinaryEncodedPropertyReader.cs&version=GBmaster&_a=contents
 
 /**
  * This contains mapping of number of bytes representing the corresponding string length to Marker Codes.
-*/
+ */
 const utf8StringBytesToCodeMap = {
-    0: 13,
-    1: 14,
-    2: 15,
-    4: 16,
+	0: 13,
+	1: 14,
+	2: 15,
+	4: 16,
 };
 
 /**
  * This contains mapping of number of bytes representing the corresponding length in which actual data(base64 string)
  * will be stored to Marker Codes.
-*/
+ */
 const binaryBytesToCodeMap = {
-    0: 32,
-    1: 33,
-    2: 34,
-    4: 35,
-    8: 16,
+	0: 32,
+	1: 33,
+	2: 34,
+	4: 35,
+	8: 16,
 };
 
 /**
  * This contains mapping of number of bytes representing the corresponding const string id to Marker Codes.
-*/
+ */
 const constStringBytesToCodeMap = {
-    1: 17,
-    2: 18,
-    4: 19,
+	1: 17,
+	2: 18,
+	4: 19,
 };
 
 /**
  * This contains mapping of number of bytes to Marker Codes representing the corresponding Integer.
-*/
+ */
 const integerBytesToCodeMap = {
-    0: 1,
-    1: 3,
-    2: 5,
-    4: 7,
-    8: 9,
+	0: 1,
+	1: 3,
+	2: 5,
+	4: 7,
+	8: 9,
 };
 
 /**
  * This contains mapping of boolean to Marker Codes representing the corresponding bool value.
-*/
+ */
 const boolToCodeMap = [
-    12, // false
-    11, // true
+	12, // false
+	11, // true
 ];
 
 /**
@@ -123,21 +121,74 @@ const boolToCodeMap = [
  * return 0 as it is usually just represented by marker code and we don't store the actual data.
  * @param num - number to encode.
  */
- export function calcLength(numArg: number) {
-    if (numArg === 0) {
-        return 0;
-    }
-    let num = numArg;
-    let lengthLen = 0;
-    while (num > 0) {
-        num = Math.floor(num / 256);
-        lengthLen++;
-    }
-    let res = 1;
-    while (res < lengthLen) {
-        res *= 2;
-    }
-    return res;
+export function calcLength(numArg: number) {
+	if (numArg === 0) {
+		return 0;
+	}
+	let num = numArg;
+	let lengthLen = 0;
+	while (num > 0) {
+		num = Math.floor(num / 256);
+		lengthLen++;
+	}
+	let res = 1;
+	while (res < lengthLen) {
+		res *= 2;
+	}
+	return res;
+}
+
+/**
+ * Implementation of serialization of blobs in buffer with Marker Codes etc.
+ * @param buffer - Buffer to serialize to.
+ * @param content - string to be serialized.
+ * @param dictionary - Const strings dictionary to be used while serializing.
+ */
+function serializeDictionaryString(
+	buffer: WriteBuffer,
+	content: string,
+	dictionary: Map<string, number>,
+) {
+	let id = dictionary.get(content);
+	let idLength: number;
+	if (id === undefined) {
+		const data = IsoBuffer.from(content, "utf8");
+		const lengthOfDataLen = calcLength(data.length);
+
+		id = dictionary.size + 1;
+		idLength = calcLength(id);
+		dictionary.set(content, id);
+		const code =
+			lengthOfDataLen > 1 || idLength > 1
+				? MarkerCodes.ConstStringDeclareBig
+				: MarkerCodes.ConstStringDeclare;
+		// Write marker code for const string.
+		buffer.write(code);
+		const bytes = getValueSafely(codeToBytesMap, code);
+		assert(
+			bytes >= lengthOfDataLen,
+			0x283 /* "Length of data len should fit in the bytes from the map" */,
+		);
+		assert(bytes >= idLength, 0x284 /* "Length of id should fit in the bytes from the map" */);
+		// Assign and write id for const string.
+		buffer.write(id, bytes);
+		// Write length of const string.
+		buffer.write(data.length, bytes);
+		// Write const string data.
+		for (const element of data) {
+			buffer.write(element);
+		}
+	} else {
+		idLength = calcLength(id);
+	}
+	// Write Marker Code
+	buffer.write(getValueSafely(constStringBytesToCodeMap, idLength));
+	// Write id of const string
+	buffer.write(id, idLength);
+}
+
+function serializeString(buffer: WriteBuffer, content: string, codeMap = binaryBytesToCodeMap) {
+	serializeBlob(buffer, IsoBuffer.from(content, "utf8"), utf8StringBytesToCodeMap);
 }
 
 /**
@@ -146,55 +197,21 @@ const boolToCodeMap = [
  * @param blob - blob to be serialized.
  * @param dictionary - Const strings dictionary to be used while serializing.
  */
-function serializeBlob(buffer: WriteBuffer, blob: BlobCore, dictionary: Map<string, number>) {
-    const data = blob.buffer;
-    const lengthOfDataLen = calcLength(data.length);
-    if (blob.constString) {
-        const content = blob.toString();
-        let id = dictionary.get(content);
-        let idLength: number;
-        if (id === undefined) {
-            id = dictionary.size + 1;
-            idLength = calcLength(id);
-            dictionary.set(content, id);
-            let code: number;
-            if (lengthOfDataLen > 1 || idLength > 1) {
-                code = MarkerCodes.ConstStringDeclareBig;
-            } else {
-                code = MarkerCodes.ConstStringDeclare;
-            }
-            // Write marker code for const string.
-            buffer.write(code);
-            const bytes = getValueSafely(codeToBytesMap, code);
-            assert(bytes >= lengthOfDataLen, 0x283 /* "Length of data len should fit in the bytes from the map" */);
-            assert(bytes >= idLength, 0x284 /* "Length of id should fit in the bytes from the map" */);
-            // Assign and write id for const string.
-            buffer.write(id, bytes);
-            // Write length of const string.
-            buffer.write(data.length, bytes);
-            // Write const string data.
-            for (const element of data) {
-                buffer.write(element);
-            }
-        } else {
-            idLength = calcLength(id);
-        }
-        // Write Marker Code
-        buffer.write(getValueSafely(constStringBytesToCodeMap, idLength));
-        // Write id of const string
-        buffer.write(id, idLength);
-    } else {
-        // Write Marker code.
-        buffer.write(blob.useUtf8Code ? getValueSafely(utf8StringBytesToCodeMap, lengthOfDataLen)
-            : getValueSafely(binaryBytesToCodeMap, lengthOfDataLen));
-        // Write actual data if length greater than 0, otherwise Marker Code is enough.
-        if (lengthOfDataLen > 0) {
-            buffer.write(data.length, lengthOfDataLen);
-            for (const element of data) {
-                buffer.write(element);
-            }
-        }
-    }
+function serializeBlob(
+	buffer: WriteBuffer,
+	data: Uint8Array,
+	codeMap: Record<number, number> = binaryBytesToCodeMap,
+) {
+	const lengthOfDataLen = calcLength(data.length);
+	// Write Marker code.
+	buffer.write(getValueSafely(codeMap, lengthOfDataLen));
+	// Write actual data if length greater than 0, otherwise Marker Code is enough.
+	if (lengthOfDataLen > 0) {
+		buffer.write(data.length, lengthOfDataLen);
+		for (const element of data) {
+			buffer.write(element);
+		}
+	}
 }
 
 /**
@@ -203,58 +220,63 @@ function serializeBlob(buffer: WriteBuffer, blob: BlobCore, dictionary: Map<stri
  * @param nodeCore - Node to be serialized.
  * @param dictionary - Const strings dictionary to be used while serializing.
  */
-function serializeNodeCore(buffer: WriteBuffer, nodeCore: NodeCore, dictionary: Map<string, number>) {
-    for (const child of nodeCore.nodes) {
-        if (child instanceof NodeCore) {
-            // For a tree node start and end with set/list start and end marker codes.
-            const startCode = MarkerCodesStart[child.type];
-            const endCode = MarkerCodesEnd[child.type];
-            assert(startCode !== undefined, 0x285 /* "Start code should not undefined" */);
-            assert(endCode !== undefined, 0x286 /* "End code should not undefined" */);
-            buffer.write(startCode);
-            serializeNodeCore(buffer, child, dictionary);
-            buffer.write(endCode);
-        } else if (child instanceof BlobCore) {
-            serializeBlob(buffer, child, dictionary);
-        } else if (typeof child === "number") {
-            // Calculate length in which integer will be stored
-            const len = calcLength(child);
-            // Write corresponding Marker code for length of integer.
-            buffer.write(getValueSafely(integerBytesToCodeMap, len));
-            // Write actual number if greater than 0, otherwise Marker Code is enough.
-            if (len > 0) {
-                buffer.write(child, len);
-            }
-        } else if (typeof child === "boolean") {
-            buffer.write(boolToCodeMap[child ? 1 : 0]);
-        } else {
-            unreachableCase(child, "Unsupported node type");
-        }
-    }
+function serializeNodeCore(
+	buffer: WriteBuffer,
+	nodeCore: NodeCore,
+	dictionary: Map<string, number>,
+) {
+	for (const child of nodeCore.nodes) {
+		if (child instanceof NodeCore) {
+			// For a tree node start and end with set/list start and end marker codes.
+			const startCode = MarkerCodesStart[child.type];
+			const endCode = MarkerCodesEnd[child.type];
+			assert(startCode !== undefined, 0x285 /* "Start code should not undefined" */);
+			assert(endCode !== undefined, 0x286 /* "End code should not undefined" */);
+			buffer.write(startCode);
+			serializeNodeCore(buffer, child, dictionary);
+			buffer.write(endCode);
+		} else if (child instanceof BlobCore) {
+			serializeBlob(buffer, child.buffer);
+		} else if (typeof child === "number") {
+			// Calculate length in which integer will be stored
+			const len = calcLength(child);
+			// Write corresponding Marker code for length of integer.
+			buffer.write(getValueSafely(integerBytesToCodeMap, len));
+			// Write actual number if greater than 0, otherwise Marker Code is enough.
+			if (len > 0) {
+				buffer.write(child, len);
+			}
+		} else if (typeof child === "boolean") {
+			buffer.write(boolToCodeMap[child ? 1 : 0]);
+		} else {
+			assert(child._stringElement, 0x3dd /* Unsupported node type */);
+			if (child.dictionary) {
+				serializeDictionaryString(buffer, child.content, dictionary);
+			} else {
+				serializeString(buffer, child.content);
+			}
+		}
+	}
 }
 
 class NodeCoreSerializer extends NodeCore {
-    constructor() {
-        super();
-    }
+	constructor() {
+		super();
+	}
 
-    public serialize(buffer: WriteBuffer) {
-        serializeNodeCore(buffer, this, new Map<string, number>());
-    }
+	public serialize(buffer: WriteBuffer) {
+		serializeNodeCore(buffer, this, new Map<string, number>());
+	}
 }
 
 export class TreeBuilderSerializer extends NodeCoreSerializer {
-    constructor() {
-        super();
-    }
-
-    static load(buffer: ReadBuffer): TreeBuilder {
-        return TreeBuilder.load(buffer);
-    }
+	constructor() {
+		super();
+	}
 
-    public serialize(): ReadBuffer {
-        const buffer = new WriteBuffer();
-        super.serialize(buffer);
-        return buffer.done();
-    }
+	public serialize(): Uint8Array {
+		const buffer = new WriteBuffer();
+		super.serialize(buffer);
+		return buffer.done();
+	}
 }

package/src/checkUrl.ts

@@ -11,24 +11,25 @@ import { getLocatorFromOdspUrl } from "./odspFluidFileLink";
  * Note that returning information here is NOT a full guarantee that resolve will ultimately be successful.
  * Instead, this should be used as a lightweight check that can filter out easily detectable unsupported URLs
  * before the entire Fluid loading process needs to be kicked off.
+ * @alpha
  */
 export function checkUrl(documentUrl: URL): DriverPreCheckInfo | undefined {
-  const locator = getLocatorFromOdspUrl(documentUrl);
+	const locator = getLocatorFromOdspUrl(documentUrl);
 
-  if (!locator) {
-    return undefined;
-  }
+	if (!locator) {
+		return undefined;
+	}
 
-  let siteOrigin: string | undefined;
-  try {
-    if (locator?.siteUrl) {
-      siteOrigin = new URL(locator?.siteUrl).origin;
-    }
-  } catch {}
+	let siteOrigin: string | undefined;
+	try {
+		if (locator?.siteUrl) {
+			siteOrigin = new URL(locator?.siteUrl).origin;
+		}
+	} catch {}
 
-  return {
-    codeDetailsHint: locator?.containerPackageName,
-    // Add the snapshot endpoint, which has the same domain as the site URL
-    criticalBootDomains: siteOrigin ? [siteOrigin] : undefined,
-  };
+	return {
+		codeDetailsHint: locator?.containerPackageName,
+		// Add the snapshot endpoint, which has the same domain as the site URL
+		criticalBootDomains: siteOrigin ? [siteOrigin] : undefined,
+	};
 }