@fluidframework/runtime-utils 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/src/objectstorageutils.ts

@@ -5,44 +5,45 @@
 
 import { ITree } from "@fluidframework/protocol-definitions";
 
+/**
+ * @internal
+ */
 export function getNormalizedObjectStoragePathParts(path: string) {
-    let normalizePath = path;
-    if (normalizePath.startsWith("/")) {
-        normalizePath = normalizePath.substr(1);
-    }
-    if (normalizePath.endsWith("/")) {
-        normalizePath = normalizePath.substr(0, normalizePath.length - 1);
-    }
-    if (normalizePath.length > 0) {
-        return normalizePath.split("/");
-    }
-    return [];
+	let normalizePath = path;
+	if (normalizePath.startsWith("/")) {
+		normalizePath = normalizePath.substr(1);
+	}
+	if (normalizePath.endsWith("/")) {
+		normalizePath = normalizePath.substr(0, normalizePath.length - 1);
+	}
+	if (normalizePath.length > 0) {
+		return normalizePath.split("/");
+	}
+	return [];
 }
 
-export async function listBlobsAtTreePath(inputTree: ITree | undefined, path: string): Promise<string[]> {
-    const pathParts = getNormalizedObjectStoragePathParts(path);
-    let tree: ITree | undefined = inputTree;
-    while (tree?.entries !== undefined && pathParts.length > 0) {
-        const part = pathParts.shift();
-        const treeEntry = tree.entries.find((value) => {
-            if (value.type === "Tree" && value.path === part) {
-                return true;
-            } else {
-                return false;
-            }
-        });
+/**
+ * @internal
+ */
+export async function listBlobsAtTreePath(
+	inputTree: ITree | undefined,
+	path: string,
+): Promise<string[]> {
+	const pathParts = getNormalizedObjectStoragePathParts(path);
+	let tree: ITree | undefined = inputTree;
+	while (tree?.entries !== undefined && pathParts.length > 0) {
+		const part = pathParts.shift();
+		const treeEntry = tree.entries.find((value) => {
+			return value.type === "Tree" && value.path === part ? true : false;
+		});
 
-        // this check is largely superfluous due to the same check being done
-        // immediately above. the type system, however, is not aware of this.
-        // so we must redundantly determine that the entry's type is "Tree"
-        if (treeEntry?.type === "Tree") {
-            tree = treeEntry.value;
-        } else {
-            tree = undefined;
-        }
-    }
-    if (tree?.entries === undefined || pathParts.length !== 0) {
-        throw new Error("path does not exist");
-    }
-    return tree.entries.filter((e) => e.type === "Blob").map((e) => e.path);
+		// this check is largely superfluous due to the same check being done
+		// immediately above. the type system, however, is not aware of this.
+		// so we must redundantly determine that the entry's type is "Tree"
+		tree = treeEntry?.type === "Tree" ? treeEntry.value : undefined;
+	}
+	if (tree?.entries === undefined || pathParts.length !== 0) {
+		throw new Error("path does not exist");
+	}
+	return tree.entries.filter((e) => e.type === "Blob").map((e) => e.path);
 }

package/src/requestParser.ts

@@ -6,100 +6,95 @@ import { IRequest, IRequestHeader } from "@fluidframework/core-interfaces";
 
 /**
  * The Request Parser takes an IRequest provides parsing and sub request creation
+ * @alpha
  */
 export class RequestParser implements IRequest {
-    /**
-     * Splits the path of the url and decodes each path part
-     * @param url - the url to get path parts of
-     */
-    public static getPathParts(url: string): readonly string[] {
-        const queryStartIndex = url.indexOf("?");
-        return url
-            .substring(0, queryStartIndex < 0 ? url.length : queryStartIndex)
-            .split("/")
-            .reduce<string[]>(
-                (pv, cv) => {
-                    if (cv !== undefined && cv.length > 0) {
-                        pv.push(decodeURIComponent(cv));
-                    }
-                    return pv;
-                },
-                []);
-    }
+	/**
+	 * Splits the path of the url and decodes each path part
+	 * @param url - the url to get path parts of
+	 */
+	public static getPathParts(url: string): readonly string[] {
+		const queryStartIndex = url.indexOf("?");
+		return url
+			.substring(0, queryStartIndex < 0 ? url.length : queryStartIndex)
+			.split("/")
+			.reduce<string[]>((pv, cv) => {
+				if (cv !== undefined && cv.length > 0) {
+					pv.push(decodeURIComponent(cv));
+				}
+				return pv;
+			}, []);
+	}
 
-    private requestPathParts: readonly string[] | undefined;
-    public readonly query: string;
+	private requestPathParts: readonly string[] | undefined;
+	public readonly query: string;
 
-    public static create(request: Readonly<IRequest>) {
-        // Perf optimizations.
-        if (request instanceof RequestParser) {
-            return request;
-        }
-        return new RequestParser(request);
-    }
+	public static create(request: Readonly<IRequest>) {
+		// Perf optimizations.
+		if (request instanceof RequestParser) {
+			return request;
+		}
+		return new RequestParser(request);
+	}
 
-    protected constructor(private readonly request: Readonly<IRequest>) {
-        const queryStartIndex = this.request.url.indexOf("?");
-        if (queryStartIndex >= 0) {
-            this.query = this.request.url.substring(queryStartIndex);
-        } else {
-            this.query = "";
-        }
-    }
+	protected constructor(private readonly request: Readonly<IRequest>) {
+		const queryStartIndex = this.request.url.indexOf("?");
+		this.query = queryStartIndex >= 0 ? this.request.url.substring(queryStartIndex) : "";
+	}
 
-    public get url(): string {
-        return this.request.url;
-    }
+	public get url(): string {
+		return this.request.url;
+	}
 
-    public get headers(): IRequestHeader | undefined {
-        return this.request.headers;
-    }
+	public get headers(): IRequestHeader | undefined {
+		return this.request.headers;
+	}
 
-    /**
-     * Returns the decoded path parts of the request's url
-     */
-    public get pathParts(): readonly string[] {
-        if (this.requestPathParts === undefined) {
-            this.requestPathParts = RequestParser.getPathParts(this.url);
-        }
-        return this.requestPathParts;
-    }
+	/**
+	 * Returns the decoded path parts of the request's url
+	 */
+	public get pathParts(): readonly string[] {
+		if (this.requestPathParts === undefined) {
+			this.requestPathParts = RequestParser.getPathParts(this.url);
+		}
+		return this.requestPathParts;
+	}
 
-    /**
-     * Returns true if it's a terminating path, i.e. no more elements after `elements` entries and empty query.
-     * @param elements - number of elements in path
-     */
-    public isLeaf(elements: number) {
-        return this.query === "" && this.pathParts.length === elements;
-    }
+	/**
+	 * Returns true if it's a terminating path, i.e. no more elements after `elements` entries and empty query.
+	 * @param elements - number of elements in path
+	 */
+	public isLeaf(elements: number) {
+		return this.query === "" && this.pathParts.length === elements;
+	}
 
-    /**
-     * Creates a sub request starting at a specific path part of this request's url
-     * The sub request url always has a leading slash, and always include query params if original url has any
-     * e.g. original url is /a/b/?queryParams, createSubRequest(0) is /a/b/?queryParams
-     * createSubRequest(1) is /b/?queryParams
-     * createSubRequest(2) is /?queryParams
-     * createSubRequest(n) where n is bigger than parts length, e.g. 2, or n is less than 0 will throw an exception
-     *
-     * note: query params are not counted towards path parts.
-     *
-     * @param startingPathIndex - The index of the first path part of the sub request
-     */
-    public createSubRequest(startingPathIndex: number): IRequest {
-        const pathLen = this.pathParts.length;
-        if (startingPathIndex < 0 || startingPathIndex > pathLen) {
-            throw new Error("incorrect sub-request");
-        }
-        if (startingPathIndex === pathLen && this.url.includes("?")) {
-            return {
-                url: `/${this.query}`,
-                headers: this.headers,
-            };
-        }
-        const path = `/${this.pathParts.slice(startingPathIndex).join("/")}`;
-        return {
-            url: this.query === "" ? path : `${path}/${this.query}`,
-            headers: this.headers,
-        };
-    }
+	/**
+	 * Creates a sub request starting at a specific path part of this request's url
+	 * The sub request url always has a leading slash, and always include query params if original url has any
+	 * e.g. original url is /a/b/?queryParams, createSubRequest(0) is /a/b/?queryParams
+	 * createSubRequest(1) is /b/?queryParams
+	 * createSubRequest(2) is /?queryParams
+	 * createSubRequest(n) where n is bigger than parts length, e.g. 2, or n is less than 0 will throw an exception
+	 *
+	 * note: query params are not counted towards path parts.
+	 *
+	 * @param startingPathIndex - The index of the first path part of the sub request
+	 */
+	public createSubRequest(startingPathIndex: number): IRequest {
+		const pathLen = this.pathParts.length;
+		if (startingPathIndex < 0 || startingPathIndex > pathLen) {
+			throw new Error("incorrect sub-request");
+		}
+		if (startingPathIndex === pathLen && this.url.includes("?")) {
+			return {
+				url: `/${this.query}`,
+				headers: this.headers,
+			};
+		}
+		const path = `/${this.pathParts.slice(startingPathIndex).join("/")}`;
+		return {
+			url: this.query === "" ? path : `${path}/${this.query}`,
+			headers: this.headers,
+		};
+	}
 }

package/src/runtimeFactoryHelper.ts

@@ -4,36 +4,37 @@
  */
 
 import {
-    IContainerContext,
-    IRuntime,
-    IRuntimeFactory,
+	IContainerContext,
+	IRuntime,
+	IRuntimeFactory,
 } from "@fluidframework/container-definitions";
 import { IContainerRuntime } from "@fluidframework/container-runtime-definitions";
 
+/**
+ * @alpha
+ */
 export abstract class RuntimeFactoryHelper<T = IContainerRuntime> implements IRuntimeFactory {
-    public get IRuntimeFactory() { return this; }
-
-    public async instantiateRuntime(
-        context: IContainerContext,
-        existing?: boolean,
-    ): Promise<IRuntime> {
-        const fromExisting = existing === undefined
-            ? context.existing === true
-            : existing;
-        const runtime = await this.preInitialize(context, fromExisting);
-
-        if (fromExisting) {
-            await this.instantiateFromExisting(runtime);
-        } else {
-            await this.instantiateFirstTime(runtime);
-        }
+	public get IRuntimeFactory() {
+		return this;
+	}
 
-        await this.hasInitialized(runtime);
-        return runtime;
-    }
+	public async instantiateRuntime(
+		context: IContainerContext,
+		existing: boolean,
+	): Promise<IRuntime> {
+		const runtime = await this.preInitialize(context, existing);
+		await (existing
+			? this.instantiateFromExisting(runtime)
+			: this.instantiateFirstTime(runtime));
+		await this.hasInitialized(runtime);
+		return runtime;
+	}
 
-    public abstract preInitialize(context: IContainerContext, existing: boolean): Promise<IRuntime & T>;
-    public async instantiateFirstTime(_runtime: T): Promise<void> {}
-    public async instantiateFromExisting(_runtime: T): Promise<void> {}
-    public async hasInitialized(_runtime: T): Promise<void> {}
+	public abstract preInitialize(
+		context: IContainerContext,
+		existing: boolean,
+	): Promise<IRuntime & T>;
+	public async instantiateFirstTime(_runtime: T): Promise<void> {}
+	public async instantiateFromExisting(_runtime: T): Promise<void> {}
+	public async hasInitialized(_runtime: T): Promise<void> {}
 }