@fluidframework/container-runtime 0.53.0 → 0.54.0-47413

package/src/runningSummarizer.ts

@@ -5,6 +5,7 @@
 
 import { IDisposable, ITelemetryLogger, ITelemetryProperties } from "@fluidframework/common-definitions";
 import { assert, delay, Deferred, PromiseTimer } from "@fluidframework/common-utils";
+import { UsageError } from "@fluidframework/container-utils";
 import {
     ISequencedDocumentMessage,
     ISummaryConfiguration,
@@ -18,7 +19,6 @@ import {
     ISummarizeHeuristicData,
     ISummarizeHeuristicRunner,
     ISummarizerOptions,
-    OnDemandSummarizeResult,
     IOnDemandSummarizeOptions,
     EnqueueSummarizeResult,
     SummarizerStopReason,
@@ -408,25 +408,27 @@ export class RunningSummarizer implements IDisposable {
     }
 
     /** {@inheritdoc (ISummarizer:interface).summarizeOnDemand} */
-    public summarizeOnDemand({
-        reason,
-        ...options
-    }: IOnDemandSummarizeOptions): OnDemandSummarizeResult {
+    public summarizeOnDemand(
+        resultsBuilder: SummarizeResultBuilder = new SummarizeResultBuilder(),
+        {
+            reason,
+            ...options
+        }: IOnDemandSummarizeOptions): ISummarizeResults {
         if (this.stopping) {
-            const failBuilder = new SummarizeResultBuilder();
-            failBuilder.fail("RunningSummarizer stopped or disposed", undefined);
-            return failBuilder.build();
+            resultsBuilder.fail("RunningSummarizer stopped or disposed", undefined);
+            return resultsBuilder.build();
         }
         // Check for concurrent summary attempts. If one is found,
         // return a promise that caller can await before trying again.
         if (this.summarizingLock !== undefined) {
             // The heuristics are blocking concurrent summarize attempts.
-            return { alreadyRunning: this.summarizingLock };
+            throw new UsageError("Attempted to run an already-running summarizer on demand");
         }
         const result = this.trySummarizeOnce(
             { summarizeReason: `onDemand/${reason}` },
             options,
-            this.cancellationToken);
+            this.cancellationToken,
+            resultsBuilder);
         return result;
     }
 

package/src/summarizer.ts

@@ -6,16 +6,23 @@
 import { EventEmitter } from "events";
 import { Deferred } from "@fluidframework/common-utils";
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ILoader, LoaderHeader } from "@fluidframework/container-definitions";
+import { UsageError } from "@fluidframework/container-utils";
+import { DriverHeader } from "@fluidframework/driver-definitions";
+import { requestFluidObject } from "@fluidframework/runtime-utils";
 import { ChildLogger, IFluidErrorBase, LoggingError, wrapErrorAndLog } from "@fluidframework/telemetry-utils";
 import {
+    FluidObject,
     IFluidHandleContext,
     IFluidHandle,
+    IRequest,
 } from "@fluidframework/core-interfaces";
 import {
     ISequencedDocumentMessage,
     ISummaryConfiguration,
 } from "@fluidframework/protocol-definitions";
 import { ICancellableSummarizerController } from "./runWhileConnectedCoordinator";
+import { summarizerClientType } from "./summarizerClientElection";
 import { SummaryCollection } from "./summaryCollection";
 import { SummarizerHandle } from "./summarizerHandle";
 import { RunningSummarizer } from "./runningSummarizer";
@@ -28,6 +35,7 @@ import {
     SummarizerStopReason,
 } from "./summarizerTypes";
 import { SummarizeHeuristicData } from "./summarizerHeuristics";
+import { SummarizeResultBuilder } from "./summaryGenerator";
 import { IConnectableRuntime } from ".";
 
 const summarizingError = "summarizingError";
@@ -67,6 +75,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
     private systemOpListener?: (op: ISequencedDocumentMessage) => void;
     private opListener?: (error: any, op: ISequencedDocumentMessage) => void;
     private _disposed: boolean = false;
+    private starting: boolean = false;
 
     private readonly innerHandle: IFluidHandle<this>;
 
@@ -94,6 +103,40 @@ export class Summarizer extends EventEmitter implements ISummarizer {
         this.innerHandle = new SummarizerHandle(this, url, handleContext);
     }
 
+    /**
+     * Creates a Summarizer and its underlying client.
+     * Note that different implementations of ILoader will handle the URL differently.
+     * ILoader provided by a ContainerRuntime is a RelativeLoader, which will treat URL's
+     * starting with "/" as relative to the Container. The general ILoader
+     * interface will expect an absolute URL and will not handle "/".
+     * @param loader - the loader that resolves the request
+     * @param url - the URL used to resolve the container
+     */
+    public static async create(
+        loader: ILoader,
+        url: string): Promise<ISummarizer> {
+        const request: IRequest = {
+            headers: {
+                [LoaderHeader.cache]: false,
+                [LoaderHeader.clientDetails]: {
+                    capabilities: { interactive: false },
+                    type: summarizerClientType,
+                },
+                [DriverHeader.summarizingClient]: true,
+                [LoaderHeader.reconnect]: false,
+            },
+            url,
+        };
+
+        const resolvedContainer = await loader.resolve(request);
+        const fluidObject =
+            await requestFluidObject<FluidObject<ISummarizer>>(resolvedContainer, { url: "_summarizer" });
+        if (fluidObject.ISummarizer === undefined) {
+            throw new UsageError("Fluid object does not implement ISummarizer");
+        }
+        return fluidObject.ISummarizer;
+    }
+
     public async run(
         onBehalfOf: string,
         options?: Readonly<Partial<ISummarizerOptions>>): Promise<SummarizerStopReason> {
@@ -120,13 +163,6 @@ export class Summarizer extends EventEmitter implements ISummarizer {
     private async runCore(
         onBehalfOf: string,
         options?: Readonly<Partial<ISummarizerOptions>>): Promise<SummarizerStopReason> {
-        // Initialize values and first ack (time is not exact)
-        this.logger.sendTelemetryEvent({
-            eventName: "RunningSummarizer",
-            onBehalfOf,
-            initSummarySeqNumber: this.runtime.deltaManager.initialSequenceNumber,
-        });
-
         const runCoordinator: ICancellableSummarizerController = await this.runCoordinatorCreateFn(this.runtime);
 
         // Wait for either external signal to cancel, or loss of connectivity.
@@ -143,10 +179,70 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             return runCoordinator.waitCancelled;
         }
 
+        const runningSummarizer = await this.start(onBehalfOf, runCoordinator, options);
+
+        // Wait for either external signal to cancel, or loss of connectivity.
+        const stopReason = await stopP;
+
+        // There are two possible approaches here:
+        // 1. Propagate cancellation from this.stopDeferred to runCoordinator. This will ensure that we move to the exit
+        //    faster, including breaking out of the RunningSummarizer.trySummarize() faster.
+        //    We could create new coordinator and pass it to waitStop() -> trySummarizeOnce("lastSummary") flow.
+        //    The con of this approach is that we might cancel active summary, and lastSummary will fail because it
+        //    did not wait for ack/nack from previous summary. Plus we disregard any 429 kind of info from service
+        //    that way (i.e. trySummarize() loop might have been waiting for 5 min because storage told us so).
+        //    In general, it's more wasted resources.
+        // 2. We can not do it and make waitStop() do last summary only if there was no active summary. This ensures
+        //    that client behaves properly (from server POV) and we do not waste resources. But, it may mean we wait
+        //    substantially longer for trySummarize() retries to play out and thus this summary loop may run into
+        //    conflict with new summarizer client starting on different client.
+        // As of now, #2 is implemented. It's more forward looking, as issue #7279 suggests changing design for new
+        // summarizer client to not be created until current summarizer fully moves to exit, and that would reduce
+        // cons of #2 substantially.
+
+        // Cleanup after running
+        await runningSummarizer.waitStop(!runCoordinator.cancelled /* allowLastSummary */);
+
+        // Propagate reason and ensure that if someone is waiting for cancellation token, they are moving to exit
+        runCoordinator.stop(stopReason);
+
+        return stopReason;
+    }
+
+    /**
+     * Put the summarizer in a started state, including creating and initializing the RunningSummarizer.
+     * The start request can come either from the SummaryManager (in the auto-summarize case) or from the user
+     * (in the on-demand case).
+     * @param onBehalfOf - ID of the client that requested that the summarizer start
+     * @param runCoordinator - cancellation token
+     * @param options - options to forward to the RunningSummarizer
+     * @returns - Promise that is fulfilled when the RunningSummarizer is ready
+     */
+    private async start(
+        onBehalfOf: string,
+        runCoordinator: ICancellableSummarizerController,
+        options?: Readonly<Partial<ISummarizerOptions>>): Promise<RunningSummarizer> {
+        if (this.runningSummarizer) {
+            if (this.runningSummarizer.disposed) {
+                throw new UsageError("Starting a disposed summarizer");
+            }
+            return this.runningSummarizer;
+        }
+        if (this.starting) {
+            throw new UsageError("Attempting to start a summarizer that is already starting");
+        }
+        this.starting = true;
+        // Initialize values and first ack (time is not exact)
+        this.logger.sendTelemetryEvent({
+            eventName: "RunningSummarizer",
+            onBehalfOf,
+            initSummarySeqNumber: this.runtime.deltaManager.initialSequenceNumber,
+        });
+
         // Summarizing container ID (with clientType === "summarizer")
         const clientId = this.runtime.clientId;
         if (clientId === undefined) {
-            throw Error("clientId should be defined if connected.");
+            throw new UsageError("clientId should be defined if connected.");
         }
 
         const runningSummarizer = await RunningSummarizer.start(
@@ -172,6 +268,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
             options,
         );
         this.runningSummarizer = runningSummarizer;
+        this.starting = false;
 
         // Handle summary acks
         // Note: no exceptions are thrown from handleSummaryAcks handler as it handles all exceptions
@@ -186,32 +283,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
         this.opListener = (error: any, op: ISequencedDocumentMessage) => runningSummarizer.handleOp(error, op);
         this.runtime.on("batchEnd", this.opListener);
 
-        // Wait for either external signal to cancel, or loss of connectivity.
-        const stopReason = await stopP;
-
-        // There are two possible approaches here:
-        // 1. Propagate cancellation from this.stopDeferred to runCoordinator. This will ensure that we move to the exit
-        //    faster, including breaking out of the RunningSummarizer.trySummarize() faster.
-        //    We could create new coordinator and pass it to waitStop() -> trySummarizeOnce("lastSummary") flow.
-        //    The con of this approach is that we might cancel active summary, and lastSummary will fail because it
-        //    did not wait for ack/nack from previous summary. Plus we disregard any 429 kind of info from service
-        //    that way (i.e. trySummarize() loop might have been waiting for 5 min because storage told us so).
-        //    In general, it's more wasted resources.
-        // 2. We can not do it and make waitStop() do last summary only if there was no active summary. This ensures
-        //    that client behaves properly (from server POV) and we do not waste resources. But, it may mean we wait
-        //    substantially longer for trySummarize() retries to play out and thus this summary loop may run into
-        //    conflict with new summarizer client starting on different client.
-        // As of now, #2 is implemented. It's more forward looking, as issue #7279 suggests changing design for new
-        // summarizer client to not be created until current summarizer fully moves to exit, and that would reduce
-        // cons of #2 substantially.
-
-        // Cleanup after running
-        await runningSummarizer.waitStop(!runCoordinator.cancelled /* allowLastSummary */);
-
-        // Propagate reason and ensure that if someone is waiting for cancellation token, they are moving to exit
-        runCoordinator.stop(stopReason);
-
-        return stopReason;
+        return runningSummarizer;
     }
 
     /**
@@ -238,15 +310,59 @@ export class Summarizer extends EventEmitter implements ISummarizer {
     }
 
     public readonly summarizeOnDemand: ISummarizer["summarizeOnDemand"] = (...args) => {
-        if (this._disposed || this.runningSummarizer === undefined || this.runningSummarizer.disposed) {
-            throw Error("Summarizer is not running or already disposed.");
+        try {
+            if (this._disposed || this.runningSummarizer?.disposed) {
+                throw new UsageError("Summarizer is already disposed.");
+            }
+            if (this.runtime.summarizerClientId !== undefined &&
+                this.runtime.summarizerClientId !== this.runtime.clientId) {
+                // If there is an elected summarizer, and it's not this one, don't allow on-demand summary.
+                // This is to prevent the on-demand summary and heuristic-based summary from stepping on
+                // each other.
+                throw new UsageError("On-demand summary attempted while an elected summarizer is present");
+            }
+            const builder = new SummarizeResultBuilder();
+            if (this.runningSummarizer) {
+                // Summarizer is already running. Go ahead and start.
+                return this.runningSummarizer.summarizeOnDemand(builder, ...args);
+            }
+
+            // Summarizer isn't running, so we need to start it, which is an async operation.
+            // Manage the promise related to creating the cancellation token here.
+            // The promises related to starting, summarizing,
+            // and submitting are communicated to the caller through the results builder.
+            const coordinatorCreateP = this.runCoordinatorCreateFn(this.runtime);
+
+            coordinatorCreateP.then((runCoordinator) => {
+                // Successully created the cancellation token. Start the summarizer.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const startP = this.start(this.runtime.clientId!, runCoordinator, { disableHeuristics: true });
+                startP.then(async (runningSummarizer) => {
+                    // Successfully started the summarizer. Run it.
+                    runningSummarizer.summarizeOnDemand(builder, ...args);
+                    // Wait for a command to stop or loss of connectivity before tearing down the summarizer and client.
+                    const stopReason = await Promise.race([this.stopDeferred.promise, runCoordinator.waitCancelled]);
+                    await runningSummarizer.waitStop(false);
+                    runCoordinator.stop(stopReason);
+                    this.dispose();
+                    this.runtime.closeFn();
+                }).catch((reason) => {
+                    builder.fail("Failed to start summarizer", reason);
+                });
+            }).catch((reason) => {
+                builder.fail("Failed to create cancellation token", reason);
+            });
+
+            return builder.build();
+        }
+        catch (error) {
+            throw SummarizingWarning.wrap(error, "summarizerRun", false /* logged */, this.logger);
         }
-        return this.runningSummarizer.summarizeOnDemand(...args);
     };
 
     public readonly enqueueSummarize: ISummarizer["enqueueSummarize"] = (...args) => {
         if (this._disposed || this.runningSummarizer === undefined || this.runningSummarizer.disposed) {
-            throw Error("Summarizer is not running or already disposed.");
+            throw new UsageError("Summarizer is not running or already disposed.");
         }
         return this.runningSummarizer.enqueueSummarize(...args);
     };

package/src/summarizerTypes.ts

@@ -238,14 +238,6 @@ export interface ISummarizeResults {
     readonly receivedSummaryAckOrNack: Promise<SummarizeResultPart<IAckSummaryResult, INackSummaryResult>>;
 }
 
-export type OnDemandSummarizeResult = (ISummarizeResults & {
-    /** Indicates that an already running summarize attempt does not exist. */
-    readonly alreadyRunning?: undefined;
-}) | {
-    /** Resolves when an already running summarize attempt completes. */
-    readonly alreadyRunning: Promise<void>;
-};
-
 export type EnqueueSummarizeResult = (ISummarizeResults & {
     /**
      * Indicates that another summarize attempt is not already enqueued,
@@ -297,6 +289,7 @@ export interface ISummarizerEvents extends IEvent {
 export interface ISummarizer extends
     IEventProvider<ISummarizerEvents>, IFluidLoadable, Partial<IProvideSummarizer>{
     stop(reason: SummarizerStopReason): void;
+
     run(onBehalfOf: string, options?: Readonly<Partial<ISummarizerOptions>>): Promise<SummarizerStopReason>;
 
     /**
@@ -308,7 +301,7 @@ export interface ISummarizer extends
      * that resolve as the summarize attempt progresses. They will resolve with success
      * false if a failure is encountered.
      */
-    summarizeOnDemand(options: IOnDemandSummarizeOptions): OnDemandSummarizeResult;
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
     /**
      * Enqueue an attempt to summarize after the specified sequence number.
      * If afterSequenceNumber is provided, the summarize attempt is "enqueued"

package/src/summaryFormat.ts

@@ -135,6 +135,7 @@ export function getMetadataFormatVersion(metadata?: IContainerRuntimeMetadata):
     return metadata?.summaryFormatVersion ?? 0;
 }
 
+export const aliasBlobName = ".aliases";
 export const metadataBlobName = ".metadata";
 export const chunksBlobName = ".chunks";
 export const electedSummarizerBlobName = ".electedSummarizer";

package/src/summaryManager.ts

@@ -6,12 +6,9 @@
 import { IDisposable, IEvent, IEventProvider, ITelemetryLogger } from "@fluidframework/common-definitions";
 import { TypedEventEmitter, assert } from "@fluidframework/common-utils";
 import { ChildLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
-import { FluidObject, IFluidRouter, IRequest } from "@fluidframework/core-interfaces";
-import { LoaderHeader } from "@fluidframework/container-definitions";
-import { DriverHeader, DriverErrorType } from "@fluidframework/driver-definitions";
-import { requestFluidObject } from "@fluidframework/runtime-utils";
+import { DriverErrorType } from "@fluidframework/driver-definitions";
 import { createSummarizingWarning } from "./summarizer";
-import { ISummarizerClientElection, summarizerClientType } from "./summarizerClientElection";
+import { ISummarizerClientElection } from "./summarizerClientElection";
 import { IThrottler } from "./throttler";
 import {
     ISummarizer,
@@ -371,47 +368,3 @@ export class SummaryManager extends TypedEventEmitter<ISummaryManagerEvents> imp
         this._disposed = true;
     }
 }
-
-export interface ISummarizerRequestOptions {
-    cache: boolean,
-    reconnect: boolean,
-    summarizingClient: boolean,
-}
-
-/**
- * Forms a function that will request a Summarizer.
- * @param loaderRouter - the loader acting as an IFluidRouter
- * @param lastSequenceNumber - the last sequence number (e.g., from DeltaManager)
- * @param cache - use cache to retrieve summarizer
- * @param summarizingClient - is summarizer client
- * @param reconnect - can reconnect on connection loss
- */
-export const formRequestSummarizerFn = (
-    loaderRouter: IFluidRouter,
-    lastSequenceNumber: number,
-    { cache, reconnect, summarizingClient }: ISummarizerRequestOptions,
-) => async () => {
-    // TODO eventually we may wish to spawn an execution context from which to run this
-    const request: IRequest = {
-        headers: {
-            [LoaderHeader.cache]: cache,
-            [LoaderHeader.clientDetails]: {
-                capabilities: { interactive: false },
-                type: summarizerClientType,
-            },
-            [DriverHeader.summarizingClient]: summarizingClient,
-            [LoaderHeader.reconnect]: reconnect,
-            [LoaderHeader.sequenceNumber]: lastSequenceNumber,
-        },
-        url: "/_summarizer",
-    };
-
-    const fluidObject = await requestFluidObject<FluidObject<ISummarizer>>(loaderRouter, request);
-    const summarizer = fluidObject.ISummarizer;
-
-    if (!summarizer) {
-        return Promise.reject(new Error("Fluid object does not implement ISummarizer"));
-    }
-
-    return summarizer;
-};

package/dist/localStorageFeatureGates.d.ts

@@ -1,13 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Helper to check if the given feature key is set in local storage.
- * @returns the following:
- * - true, if the key is set and the value is "1".
- * - false, if the key is set and the value is "0".
- * - undefined, if local storage is not available or the key is not set.
- */
-export declare function getLocalStorageFeatureGate(key: string): boolean | undefined;
-//# sourceMappingURL=localStorageFeatureGates.d.ts.map

package/dist/localStorageFeatureGates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"localStorageFeatureGates.d.ts","sourceRoot":"","sources":["../src/localStorageFeatureGates.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAc3E"}

package/dist/localStorageFeatureGates.js

@@ -1,31 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLocalStorageFeatureGate = void 0;
-/**
- * Helper to check if the given feature key is set in local storage.
- * @returns the following:
- * - true, if the key is set and the value is "1".
- * - false, if the key is set and the value is "0".
- * - undefined, if local storage is not available or the key is not set.
- */
-function getLocalStorageFeatureGate(key) {
-    try {
-        if (typeof localStorage === "object" && localStorage !== null) {
-            const itemValue = localStorage.getItem(key);
-            if (itemValue === "1") {
-                return true;
-            }
-            if (itemValue === "0") {
-                return false;
-            }
-        }
-    }
-    catch (e) { }
-    return undefined;
-}
-exports.getLocalStorageFeatureGate = getLocalStorageFeatureGate;
-//# sourceMappingURL=localStorageFeatureGates.js.map

package/dist/localStorageFeatureGates.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"localStorageFeatureGates.js","sourceRoot":"","sources":["../src/localStorageFeatureGates.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;;;;;GAMG;AACH,SAAgB,0BAA0B,CAAC,GAAW;IAClD,IAAI;QACA,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,YAAY,KAAK,IAAI,EAAE;YAC3D,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC5C,IAAK,SAAS,KAAK,GAAG,EAAE;gBACpB,OAAO,IAAI,CAAC;aACf;YACD,IAAI,SAAS,KAAK,GAAG,EAAE;gBACnB,OAAO,KAAK,CAAC;aAChB;SACJ;KACJ;IAAC,OAAO,CAAC,EAAE,GAAE;IAEd,OAAO,SAAS,CAAC;AACrB,CAAC;AAdD,gEAcC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Helper to check if the given feature key is set in local storage.\n * @returns the following:\n * - true, if the key is set and the value is \"1\".\n * - false, if the key is set and the value is \"0\".\n * - undefined, if local storage is not available or the key is not set.\n */\nexport function getLocalStorageFeatureGate(key: string): boolean | undefined {\n    try {\n        if (typeof localStorage === \"object\" && localStorage !== null) {\n            const itemValue = localStorage.getItem(key);\n            if  (itemValue === \"1\") {\n                return true;\n            }\n            if (itemValue === \"0\") {\n                return false;\n            }\n        }\n    } catch (e) {}\n\n    return undefined;\n}\n"]}

package/lib/localStorageFeatureGates.d.ts

@@ -1,13 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Helper to check if the given feature key is set in local storage.
- * @returns the following:
- * - true, if the key is set and the value is "1".
- * - false, if the key is set and the value is "0".
- * - undefined, if local storage is not available or the key is not set.
- */
-export declare function getLocalStorageFeatureGate(key: string): boolean | undefined;
-//# sourceMappingURL=localStorageFeatureGates.d.ts.map

package/lib/localStorageFeatureGates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"localStorageFeatureGates.d.ts","sourceRoot":"","sources":["../src/localStorageFeatureGates.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAc3E"}

package/lib/localStorageFeatureGates.js

@@ -1,27 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * Helper to check if the given feature key is set in local storage.
- * @returns the following:
- * - true, if the key is set and the value is "1".
- * - false, if the key is set and the value is "0".
- * - undefined, if local storage is not available or the key is not set.
- */
-export function getLocalStorageFeatureGate(key) {
-    try {
-        if (typeof localStorage === "object" && localStorage !== null) {
-            const itemValue = localStorage.getItem(key);
-            if (itemValue === "1") {
-                return true;
-            }
-            if (itemValue === "0") {
-                return false;
-            }
-        }
-    }
-    catch (e) { }
-    return undefined;
-}
-//# sourceMappingURL=localStorageFeatureGates.js.map

package/lib/localStorageFeatureGates.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"localStorageFeatureGates.js","sourceRoot":"","sources":["../src/localStorageFeatureGates.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CAAC,GAAW;IAClD,IAAI;QACA,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,YAAY,KAAK,IAAI,EAAE;YAC3D,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC5C,IAAK,SAAS,KAAK,GAAG,EAAE;gBACpB,OAAO,IAAI,CAAC;aACf;YACD,IAAI,SAAS,KAAK,GAAG,EAAE;gBACnB,OAAO,KAAK,CAAC;aAChB;SACJ;KACJ;IAAC,OAAO,CAAC,EAAE,GAAE;IAEd,OAAO,SAAS,CAAC;AACrB,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Helper to check if the given feature key is set in local storage.\n * @returns the following:\n * - true, if the key is set and the value is \"1\".\n * - false, if the key is set and the value is \"0\".\n * - undefined, if local storage is not available or the key is not set.\n */\nexport function getLocalStorageFeatureGate(key: string): boolean | undefined {\n    try {\n        if (typeof localStorage === \"object\" && localStorage !== null) {\n            const itemValue = localStorage.getItem(key);\n            if  (itemValue === \"1\") {\n                return true;\n            }\n            if (itemValue === \"0\") {\n                return false;\n            }\n        }\n    } catch (e) {}\n\n    return undefined;\n}\n"]}

package/src/localStorageFeatureGates.ts

@@ -1,27 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Helper to check if the given feature key is set in local storage.
- * @returns the following:
- * - true, if the key is set and the value is "1".
- * - false, if the key is set and the value is "0".
- * - undefined, if local storage is not available or the key is not set.
- */
-export function getLocalStorageFeatureGate(key: string): boolean | undefined {
-    try {
-        if (typeof localStorage === "object" && localStorage !== null) {
-            const itemValue = localStorage.getItem(key);
-            if  (itemValue === "1") {
-                return true;
-            }
-            if (itemValue === "0") {
-                return false;
-            }
-        }
-    } catch (e) {}
-
-    return undefined;
-}