@fluidframework/tool-utils 2.0.0-internal.3.0.1 → 2.0.0-internal.3.1.0

package/src/fluidToolRC.ts

@@ -11,54 +11,54 @@ import { lock } from "proper-lockfile";
 import { IOdspTokens } from "@fluidframework/odsp-doclib-utils";
 
 export interface IAsyncCache<TKey, TValue> {
-    get(key: TKey): Promise<TValue | undefined>;
-    save(key: TKey, value: TValue): Promise<void>;
-    lock<T>(callback: () => Promise<T>): Promise<T>;
+	get(key: TKey): Promise<TValue | undefined>;
+	save(key: TKey, value: TValue): Promise<void>;
+	lock<T>(callback: () => Promise<T>): Promise<T>;
 }
 
 export interface IResources {
-    tokens?: {
-        version?: number;
-        data: {
-            [key: string]: {
-                storage?: IOdspTokens;
-                push?: IOdspTokens;
-            };
-        };
-    };
+	tokens?: {
+		version?: number;
+		data: {
+			[key: string]: {
+				storage?: IOdspTokens;
+				push?: IOdspTokens;
+			};
+		};
+	};
 }
 
 const getRCFileName = () => path.join(os.homedir(), ".fluidtoolrc");
 
 export async function loadRC(): Promise<IResources> {
-    const readFile = util.promisify(fs.readFile);
-    const exists = util.promisify(fs.exists);
-    const fileName = getRCFileName();
-    if (await exists(fileName)) {
-        const buf = await readFile(fileName);
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return JSON.parse(buf.toString("utf8"));
-        } catch (e) {
-            // Nothing
-        }
-    }
-    return {};
+	const readFile = util.promisify(fs.readFile);
+	const exists = util.promisify(fs.exists);
+	const fileName = getRCFileName();
+	if (await exists(fileName)) {
+		const buf = await readFile(fileName);
+		try {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+			return JSON.parse(buf.toString("utf8"));
+		} catch (e) {
+			// Nothing
+		}
+	}
+	return {};
 }
 
 export async function saveRC(rc: IResources) {
-    const writeFile = util.promisify(fs.writeFile);
-    const content = JSON.stringify(rc, undefined, 2);
-    return writeFile(getRCFileName(), Buffer.from(content, "utf8"));
+	const writeFile = util.promisify(fs.writeFile);
+	const content = JSON.stringify(rc, undefined, 2);
+	return writeFile(getRCFileName(), Buffer.from(content, "utf8"));
 }
 
 export async function lockRC() {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return lock(getRCFileName(), {
-        retries: {
-            forever: true,
-        },
-        stale: 60000,
-        realpath: false,
-    });
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	return lock(getRCFileName(), {
+		retries: {
+			forever: true,
+		},
+		stale: 60000,
+		realpath: false,
+	});
 }

package/src/httpHelpers.ts

@@ -7,53 +7,67 @@ import http from "http";
 import { Socket } from "net";
 
 export interface ITrackedHttpServer {
-    readonly server: http.Server;
-    readonly sockets: Set<Socket>;
-    fullyClose(): void;
+	readonly server: http.Server;
+	readonly sockets: Set<Socket>;
+	fullyClose(): void;
 }
-export function createTrackedServer(port: number, requestListener: http.RequestListener): ITrackedHttpServer {
-    const server = http.createServer(requestListener).listen(port);
-    const sockets = new Set<Socket>();
+export function createTrackedServer(
+	port: number,
+	requestListener: http.RequestListener,
+): ITrackedHttpServer {
+	const server = http.createServer(requestListener).listen(port);
+	const sockets = new Set<Socket>();
 
-    server.on("connection", (socket) => {
-        sockets.add(socket);
-        socket.on("close", () => sockets.delete(socket));
-    });
+	server.on("connection", (socket) => {
+		sockets.add(socket);
+		socket.on("close", () => sockets.delete(socket));
+	});
 
-    return {
-        server, sockets, fullyClose() {
-            server.close();
-            sockets.forEach((socket) => socket.destroy());
-        },
-    };
+	return {
+		server,
+		sockets,
+		fullyClose() {
+			server.close();
+			sockets.forEach((socket) => socket.destroy());
+		},
+	};
 }
-export type OnceListenerHandler<T> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<T>;
+export type OnceListenerHandler<T> = (
+	req: http.IncomingMessage,
+	res: http.ServerResponse,
+) => Promise<T>;
 export type OnceListenerResult<T> = Promise<() => Promise<T>>;
-export const serverListenAndHandle = async <T>(port: number, handler: OnceListenerHandler<T>): OnceListenerResult<T> =>
-    // eslint-disable-next-line promise/param-names
-    new Promise((outerResolve, outerReject) => {
-    // eslint-disable-next-line promise/param-names
-        const innerP = new Promise<T>((innerResolve, innerReject) => {
-            const httpServer = createTrackedServer(port, (req, res) => {
-                // ignore favicon
-                if (req.url === "/favicon.ico") {
-                    res.writeHead(200, { "Content-Type": "image/x-icon" });
-                    res.end();
-                    return;
-                }
-                handler(req, res).finally(() => httpServer.fullyClose()).then(
-                    (result) => innerResolve(result),
-                    (error) => innerReject(error),
-                );
-            });
-            outerResolve(async () => innerP);
-        });
-    });
+export const serverListenAndHandle = async <T>(
+	port: number,
+	handler: OnceListenerHandler<T>,
+): OnceListenerResult<T> =>
+	// eslint-disable-next-line promise/param-names
+	new Promise((outerResolve, outerReject) => {
+		// eslint-disable-next-line promise/param-names
+		const innerP = new Promise<T>((innerResolve, innerReject) => {
+			const httpServer = createTrackedServer(port, (req, res) => {
+				// ignore favicon
+				if (req.url === "/favicon.ico") {
+					res.writeHead(200, { "Content-Type": "image/x-icon" });
+					res.end();
+					return;
+				}
+				handler(req, res)
+					.finally(() => httpServer.fullyClose())
+					.then(
+						(result) => innerResolve(result),
+						(error) => innerReject(error),
+					);
+			});
+			outerResolve(async () => innerP);
+		});
+	});
 
-export const endResponse = async (response: http.ServerResponse): Promise<void> => new Promise((resolve, reject) => {
-    try {
-        response.end(resolve);
-    } catch (error) {
-        reject(error);
-    }
-});
+export const endResponse = async (response: http.ServerResponse): Promise<void> =>
+	new Promise((resolve, reject) => {
+		try {
+			response.end(resolve);
+		} catch (error) {
+			reject(error);
+		}
+	});

package/src/index.ts

@@ -11,4 +11,8 @@ export {
 	OdspTokenManager,
 	odspTokensCache,
 } from "./odspTokenManager";
-export { gcBlobPrefix, getNormalizedSnapshot, ISnapshotNormalizerConfig } from "./snapshotNormalizer";
+export {
+	gcBlobPrefix,
+	getNormalizedSnapshot,
+	ISnapshotNormalizerConfig,
+} from "./snapshotNormalizer";