@scalar/workspace-store 0.40.2 → 0.40.4

package/dist/plugins/client/persistence.js

@@ -1,98 +1,103 @@
-import { debounce } from "@scalar/helpers/general/debounce";
-import { createWorkspaceStorePersistence } from "../../persistence/index.js";
-const pendingFlushes = /* @__PURE__ */ new Set();
+import { debounce } from '@scalar/helpers/general/debounce';
+import { createWorkspaceStorePersistence } from '../../persistence/index.js';
+const pendingFlushes = new Set();
+// Flag to ensure lifecycle event listeners are only initialized once
 let persistenceLifecycleListenersInitialized = false;
+/**
+ * Runs (calls) all pending flush functions.
+ */
 const runPendingFlushes = () => {
-  for (const flush of pendingFlushes) {
-    flush();
-  }
-};
-const initializePersistenceLifecycleListeners = () => {
-  if (persistenceLifecycleListenersInitialized || typeof window === "undefined" || typeof document === "undefined") {
-    return;
-  }
-  persistenceLifecycleListenersInitialized = true;
-  window.addEventListener("pagehide", runPendingFlushes);
-  window.addEventListener("beforeunload", runPendingFlushes);
-  document.addEventListener("visibilitychange", () => {
-    if (document.visibilityState === "hidden") {
-      runPendingFlushes();
+    for (const flush of pendingFlushes) {
+        flush(); // Call the flush function
     }
-  });
 };
-const persistencePlugin = async ({
-  workspaceId,
-  debounceDelay = 500,
-  /** Maximum time in milliseconds to wait before forcing execution, even with continuous calls. */
-  maxWait = 1e4
-}) => {
-  const persistence = await createWorkspaceStorePersistence();
-  const { execute, flushAll } = debounce({ delay: debounceDelay, maxWait });
-  pendingFlushes.add(flushAll);
-  initializePersistenceLifecycleListeners();
-  const dispose = () => {
-    flushAll();
-    pendingFlushes.delete(flushAll);
-  };
-  return {
-    dispose,
-    hooks: {
-      /**
-       * Handles all workspace state change events.
-       * Each write is debounced by a composite key to prevent frequent writes for the same entity.
-       */
-      onWorkspaceStateChanges(event) {
-        if (event.type === "meta") {
-          return execute(`meta-${workspaceId}`, () => persistence.meta.setItem(workspaceId, event.value));
-        }
-        if (event.type === "documents") {
-          return execute(
-            `documents-${workspaceId}-${event.documentName}`,
-            () => persistence.documents.setItem(workspaceId, event.documentName, event.value)
-          );
-        }
-        if (event.type === "intermediateDocuments") {
-          return execute(
-            `intermediateDocuments-${workspaceId}-${event.documentName}`,
-            () => persistence.intermediateDocuments.setItem(workspaceId, event.documentName, event.value)
-          );
-        }
-        if (event.type === "originalDocuments") {
-          return execute(
-            `originalDocuments-${workspaceId}-${event.documentName}`,
-            () => persistence.originalDocuments.setItem(workspaceId, event.documentName, event.value)
-          );
-        }
-        if (event.type === "overrides") {
-          return execute(
-            `overrides-${workspaceId}-${event.documentName}`,
-            () => persistence.overrides.setItem(workspaceId, event.documentName, event.value)
-          );
-        }
-        if (event.type === "history") {
-          return execute(
-            `history-${workspaceId}-${event.documentName}`,
-            () => persistence.history.setItem(workspaceId, event.documentName, event.value)
-          );
-        }
-        if (event.type === "auth") {
-          return execute(
-            `auth-${workspaceId}-${event.documentName}`,
-            () => persistence.auth.setItem(workspaceId, event.documentName, event.value)
-          );
-        }
-        if (event.type === "deleteDocument") {
-          return execute(
-            `deleteDocument-${workspaceId}-${event.documentName}`,
-            () => persistence.workspace.deleteDocument(workspaceId, event.documentName)
-          );
-        }
+/**
+ * Adds event listeners to ensure flushing on important lifecycle events
+ * (like navigation away or page hide). Ensures they're registered only once.
+ */
+const initializePersistenceLifecycleListeners = () => {
+    // Avoid adding listeners multiple times or during SSR/non-browser environments
+    if (persistenceLifecycleListenersInitialized || typeof window === 'undefined' || typeof document === 'undefined') {
         return;
-      }
     }
-  };
+    persistenceLifecycleListenersInitialized = true;
+    // Trigger flush on pagehide (browser is unloading or navigating away)
+    window.addEventListener('pagehide', runPendingFlushes);
+    // Also trigger flush on beforeunload as a fallback
+    window.addEventListener('beforeunload', runPendingFlushes);
+    // For SPAs: trigger flush when the page goes hidden (such as switching tabs)
+    document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+            runPendingFlushes();
+        }
+    });
 };
-export {
-  persistencePlugin
+/**
+ * Plugin to persist workspace state changes with debounced writes.
+ * Each type of change (meta, documentConfigs, documents, etc.) is debounced by key (type + workspaceId + optional documentName).
+ * The debounce delay can be customized, defaults to 500ms.
+ *
+ * This avoids excessive writes to IndexedDB or other persistence layer when changes occur rapidly.
+ */
+export const persistencePlugin = async ({ workspaceId, debounceDelay = 500, 
+/** Maximum time in milliseconds to wait before forcing execution, even with continuous calls. */
+maxWait = 10000, }) => {
+    // Create the persistence instance (e.g., IndexedDB, localForage, etc.)
+    const persistence = await createWorkspaceStorePersistence();
+    // Debounced execute function for batching similar state changes
+    const { execute, flushAll } = debounce({ delay: debounceDelay, maxWait });
+    pendingFlushes.add(flushAll);
+    initializePersistenceLifecycleListeners();
+    const dispose = () => {
+        // Flush any pending writes and clear timers before removing from the set.
+        // Otherwise pending data can be lost if the workspace is torn down and a
+        // lifecycle event (e.g. pagehide) never fires or fires after the callback was removed.
+        flushAll();
+        pendingFlushes.delete(flushAll);
+    };
+    return {
+        dispose,
+        hooks: {
+            /**
+             * Handles all workspace state change events.
+             * Each write is debounced by a composite key to prevent frequent writes for the same entity.
+             */
+            onWorkspaceStateChanges(event) {
+                // If the event is for workspace meta data, debounce by workspaceId
+                if (event.type === 'meta') {
+                    return execute(`meta-${workspaceId}`, () => persistence.meta.setItem(workspaceId, event.value));
+                }
+                // Debounce per document content and workspace
+                if (event.type === 'documents') {
+                    return execute(`documents-${workspaceId}-${event.documentName}`, () => persistence.documents.setItem(workspaceId, event.documentName, event.value));
+                }
+                // Debounce per intermediate document and workspace
+                if (event.type === 'intermediateDocuments') {
+                    return execute(`intermediateDocuments-${workspaceId}-${event.documentName}`, () => persistence.intermediateDocuments.setItem(workspaceId, event.documentName, event.value));
+                }
+                // Debounce per original document and workspace
+                if (event.type === 'originalDocuments') {
+                    return execute(`originalDocuments-${workspaceId}-${event.documentName}`, () => persistence.originalDocuments.setItem(workspaceId, event.documentName, event.value));
+                }
+                // Debounce per document override and workspace
+                if (event.type === 'overrides') {
+                    return execute(`overrides-${workspaceId}-${event.documentName}`, () => persistence.overrides.setItem(workspaceId, event.documentName, event.value));
+                }
+                // Debounce per document history and workspace
+                if (event.type === 'history') {
+                    return execute(`history-${workspaceId}-${event.documentName}`, () => persistence.history.setItem(workspaceId, event.documentName, event.value));
+                }
+                // Debounce per document auth and workspace
+                if (event.type === 'auth') {
+                    return execute(`auth-${workspaceId}-${event.documentName}`, () => persistence.auth.setItem(workspaceId, event.documentName, event.value));
+                }
+                // Delete document
+                if (event.type === 'deleteDocument') {
+                    return execute(`deleteDocument-${workspaceId}-${event.documentName}`, () => persistence.workspace.deleteDocument(workspaceId, event.documentName));
+                }
+                // No action for other event types
+                return;
+            },
+        },
+    };
 };
-//# sourceMappingURL=persistence.js.map

package/dist/resolve.js

@@ -1,28 +1,21 @@
-import { Type } from "@scalar/typebox";
-import { getResolvedRef } from "./helpers/get-resolved-ref.js";
-import { compose } from "./schemas/compose.js";
-import { coerceValue } from "./schemas/typebox-coerce.js";
-import { SchemaObjectSchema } from "./schemas/v3.1/strict/openapi-document.js";
+import { Type } from '@scalar/typebox';
+import { getResolvedRef } from './helpers/get-resolved-ref.js';
+import { compose } from './schemas/compose.js';
+import { coerceValue } from './schemas/typebox-coerce.js';
+import { SchemaObjectSchema } from './schemas/v3.1/strict/openapi-document.js';
 const mergeSiblingReferences = (node) => {
-  const { "$ref-value": value, ...rest } = node;
-  return {
-    ...value,
-    ...rest
-  };
+    const { '$ref-value': value, ...rest } = node;
+    return {
+        ...value,
+        ...rest,
+    };
 };
-const resolve = {
-  schema: (schema) => {
-    if (schema === void 0) {
-      return void 0;
-    }
-    const resoled = getResolvedRef(schema, mergeSiblingReferences);
-    return coerceValue(
-      compose(SchemaObjectSchema, Type.Object({ $ref: Type.Optional(Type.String()) })),
-      resoled
-    );
-  }
+export const resolve = {
+    schema: (schema) => {
+        if (schema === undefined) {
+            return undefined;
+        }
+        const resoled = getResolvedRef(schema, mergeSiblingReferences);
+        return coerceValue(compose(SchemaObjectSchema, Type.Object({ $ref: Type.Optional(Type.String()) })), resoled);
+    },
 };
-export {
-  resolve
-};
-//# sourceMappingURL=resolve.js.map

package/dist/schemas/compose.js

@@ -1,8 +1,7 @@
-import { Type } from "@scalar/typebox";
-const compose = (...args) => {
-  return Type.Composite(args);
+import { Type } from '@scalar/typebox';
+/**
+ * Work around for: https://github.com/sinclairzx81/typebox/issues/1264
+ */
+export const compose = (...args) => {
+    return Type.Composite(args);
 };
-export {
-  compose
-};
-//# sourceMappingURL=compose.js.map

package/dist/schemas/extensions/document/x-internal.js

@@ -1,8 +1,4 @@
-import { Type } from "@scalar/typebox";
-const XInternalSchema = Type.Object({
-  "x-internal": Type.Optional(Type.Boolean())
+import { Type } from '@scalar/typebox';
+export const XInternalSchema = Type.Object({
+    'x-internal': Type.Optional(Type.Boolean()),
 });
-export {
-  XInternalSchema
-};
-//# sourceMappingURL=x-internal.js.map

package/dist/schemas/extensions/document/x-scalar-environments.js

@@ -1,25 +1,19 @@
-import { Type } from "@scalar/typebox";
-const xScalarEnvVarSchema = Type.Object({
-  name: Type.String(),
-  value: Type.Union([
-    Type.Object({
-      description: Type.Optional(Type.String()),
-      default: Type.String({ default: "" })
-    }),
-    Type.String()
-  ])
+import { Type } from '@scalar/typebox';
+export const xScalarEnvVarSchema = Type.Object({
+    name: Type.String(),
+    value: Type.Union([
+        Type.Object({
+            description: Type.Optional(Type.String()),
+            default: Type.String({ default: '' }),
+        }),
+        Type.String(),
+    ]),
 });
-const xScalarEnvironmentSchema = Type.Object({
-  description: Type.Optional(Type.String()),
-  color: Type.String({ default: "#FFFFFF" }),
-  variables: Type.Array(xScalarEnvVarSchema)
+export const xScalarEnvironmentSchema = Type.Object({
+    description: Type.Optional(Type.String()),
+    color: Type.String({ default: '#FFFFFF' }),
+    variables: Type.Array(xScalarEnvVarSchema),
 });
-const xScalarEnvironmentsSchema = Type.Object({
-  "x-scalar-environments": Type.Optional(Type.Record(Type.String(), xScalarEnvironmentSchema))
+export const xScalarEnvironmentsSchema = Type.Object({
+    'x-scalar-environments': Type.Optional(Type.Record(Type.String(), xScalarEnvironmentSchema)),
 });
-export {
-  xScalarEnvVarSchema,
-  xScalarEnvironmentSchema,
-  xScalarEnvironmentsSchema
-};
-//# sourceMappingURL=x-scalar-environments.js.map

package/dist/schemas/extensions/document/x-scalar-icon.js

@@ -1,8 +1,4 @@
-import { Type } from "@scalar/typebox";
-const XScalarIconSchema = Type.Object({
-  "x-scalar-icon": Type.Optional(Type.String())
+import { Type } from '@scalar/typebox';
+export const XScalarIconSchema = Type.Object({
+    'x-scalar-icon': Type.Optional(Type.String()),
 });
-export {
-  XScalarIconSchema
-};
-//# sourceMappingURL=x-scalar-icon.js.map

package/dist/schemas/extensions/document/x-scalar-ignore.js

@@ -1,8 +1,4 @@
-import { Type } from "@scalar/typebox";
-const XScalarIgnoreSchema = Type.Object({
-  "x-scalar-ignore": Type.Optional(Type.Boolean())
+import { Type } from '@scalar/typebox';
+export const XScalarIgnoreSchema = Type.Object({
+    'x-scalar-ignore': Type.Optional(Type.Boolean()),
 });
-export {
-  XScalarIgnoreSchema
-};
-//# sourceMappingURL=x-scalar-ignore.js.map

package/dist/schemas/extensions/document/x-scalar-is-dirty.js

@@ -1,9 +1,22 @@
-import { Type } from "@scalar/typebox";
-const XScalarIsDirtySchema = Type.Object({
-  /** Whether the document state is dirty, this is used to track if the document has been modified since it was last saved */
-  "x-scalar-is-dirty": Type.Optional(Type.Boolean())
+import { Type } from '@scalar/typebox';
+/**
+ * Schema for the "x-scalar-is-dirty" OpenAPI extension.
+ * This extension allows specifying an optional boolean value,
+ * which can be used to track if the document state is dirty.
+ *
+ * This is used to track if the document has been modified since it was last saved.
+ *
+ * @example
+ * ```yaml
+ * x-scalar-is-dirty: true
+ * ```
+ *
+ * @example
+ * ```yaml
+ * x-scalar-is-dirty: false
+ * ```
+ */
+export const XScalarIsDirtySchema = Type.Object({
+    /** Whether the document state is dirty, this is used to track if the document has been modified since it was last saved */
+    'x-scalar-is-dirty': Type.Optional(Type.Boolean()),
 });
-export {
-  XScalarIsDirtySchema
-};
-//# sourceMappingURL=x-scalar-is-dirty.js.map

package/dist/schemas/extensions/document/x-scalar-original-document-hash.js

@@ -1,9 +1,18 @@
-import { Type } from "@scalar/typebox";
-const XScalarOriginalDocumentHashSchema = Type.Object({
-  /** Original input document hash */
-  "x-scalar-original-document-hash": Type.String()
+import { Type } from '@scalar/typebox';
+/**
+ * Schema for the "x-scalar-original-document-hash" OpenAPI extension.
+ * This extension allows specifying an optional string value,
+ * which can be used to track the original document hash.
+ *
+ * This is used to track the original document hash when loading a document from an external source.
+ * Which can be helpful to track if the document has been modified since it was last saved.
+ *
+ * @example
+ * ```yaml
+ * x-scalar-original-document-hash: "1234567890"
+ * ```
+ */
+export const XScalarOriginalDocumentHashSchema = Type.Object({
+    /** Original input document hash */
+    'x-scalar-original-document-hash': Type.String(),
 });
-export {
-  XScalarOriginalDocumentHashSchema
-};
-//# sourceMappingURL=x-scalar-original-document-hash.js.map

package/dist/schemas/extensions/document/x-scalar-registry-meta.js

@@ -1,22 +1,16 @@
-import { Type } from "@scalar/typebox";
-const XScalarRegistryMetaSchema = Type.Object({
-  /**
-   * The registry meta for the document.
-   */
-  "x-scalar-registry-meta": Type.Optional(
-    Type.Object({
-      /**
-       * The namespace under which this registry meta is scoped.
-       */
-      "namespace": Type.String(),
-      /**
-       * A unique slug identifier for this registry meta within the namespace.
-       */
-      "slug": Type.String()
-    })
-  )
+import { Type } from '@scalar/typebox';
+export const XScalarRegistryMetaSchema = Type.Object({
+    /**
+     * The registry meta for the document.
+     */
+    'x-scalar-registry-meta': Type.Optional(Type.Object({
+        /**
+         * The namespace under which this registry meta is scoped.
+         */
+        'namespace': Type.String(),
+        /**
+         * A unique slug identifier for this registry meta within the namespace.
+         */
+        'slug': Type.String(),
+    })),
 });
-export {
-  XScalarRegistryMetaSchema
-};
-//# sourceMappingURL=x-scalar-registry-meta.js.map

package/dist/schemas/extensions/document/x-scalar-sdk-installation.js

@@ -1,16 +1,8 @@
-import { Type } from "@scalar/typebox";
-const XScalarSdkInstallationSchema = Type.Object({
-  "x-scalar-sdk-installation": Type.Optional(
-    Type.Array(
-      Type.Object({
+import { Type } from '@scalar/typebox';
+export const XScalarSdkInstallationSchema = Type.Object({
+    'x-scalar-sdk-installation': Type.Optional(Type.Array(Type.Object({
         lang: Type.String(),
         source: Type.Optional(Type.String()),
-        description: Type.Optional(Type.String())
-      })
-    )
-  )
+        description: Type.Optional(Type.String()),
+    }))),
 });
-export {
-  XScalarSdkInstallationSchema
-};
-//# sourceMappingURL=x-scalar-sdk-installation.js.map

package/dist/schemas/extensions/document/x-scalar-watch-mode.js

@@ -1,9 +1,5 @@
-import { Type } from "@scalar/typebox";
-const XScalarWatchModeSchema = Type.Object({
-  /** Whether the document is in watch mode */
-  "x-scalar-watch-mode": Type.Optional(Type.Boolean())
+import { Type } from '@scalar/typebox';
+export const XScalarWatchModeSchema = Type.Object({
+    /** Whether the document is in watch mode */
+    'x-scalar-watch-mode': Type.Optional(Type.Boolean()),
 });
-export {
-  XScalarWatchModeSchema
-};
-//# sourceMappingURL=x-scalar-watch-mode.js.map

package/dist/schemas/extensions/document/x-tags.js

@@ -1,8 +1,4 @@
-import { Type } from "@scalar/typebox";
-const XTags = Type.Object({
-  "x-tags": Type.Optional(Type.Array(Type.String()))
+import { Type } from '@scalar/typebox';
+export const XTags = Type.Object({
+    'x-tags': Type.Optional(Type.Array(Type.String())),
 });
-export {
-  XTags
-};
-//# sourceMappingURL=x-tags.js.map

package/dist/schemas/extensions/example/x-disabled.js

@@ -1,8 +1,18 @@
-import { Type } from "@scalar/typebox";
-const XDisabled = Type.Object({
-  "x-disabled": Type.Optional(Type.Boolean())
+import { Type } from '@scalar/typebox';
+/**
+ * OpenAPI extension to control whether a parameter example is enabled (checkbox on) or disabled (checkbox off).
+ *
+ * This extension is typically used in API tools to determine if a parameter (such as a header, query, or cookie)
+ * should be included in the request when sending an example. If `x-disabled: true`, the parameter example is considered
+ * "off" (checkbox unchecked) and will not be sent with the request. If `x-disabled: false` or omitted, the parameter
+ * example is "on" (checkbox checked) and will be sent.
+ *
+ * @example
+ * ```yaml
+ * x-disabled: true   # Do not send this parameter example in the request
+ * x-disabled: false  # Send this parameter example in the request
+ * ```
+ */
+export const XDisabled = Type.Object({
+    'x-disabled': Type.Optional(Type.Boolean()),
 });
-export {
-  XDisabled
-};
-//# sourceMappingURL=x-disabled.js.map

package/dist/schemas/extensions/general/x-scalar-active-environment.js

@@ -1,8 +1,5 @@
-import { Type } from "@scalar/typebox";
-const XScalarActiveEnvironmentSchema = Type.Object({
-  "x-scalar-active-environment": Type.Optional(Type.String())
+import { Type } from '@scalar/typebox';
+// Schema for the optional 'x-scalar-active-environment' extension property
+export const XScalarActiveEnvironmentSchema = Type.Object({
+    'x-scalar-active-environment': Type.Optional(Type.String()),
 });
-export {
-  XScalarActiveEnvironmentSchema
-};
-//# sourceMappingURL=x-scalar-active-environment.js.map

package/dist/schemas/extensions/general/x-scalar-cookies.js

@@ -1,16 +1,11 @@
-import { Type } from "@scalar/typebox";
-const xScalarCookieSchema = Type.Object({
-  name: Type.String(),
-  value: Type.String(),
-  domain: Type.Optional(Type.String()),
-  path: Type.Optional(Type.String()),
-  isDisabled: Type.Optional(Type.Boolean())
+import { Type } from '@scalar/typebox';
+export const xScalarCookieSchema = Type.Object({
+    name: Type.String(),
+    value: Type.String(),
+    domain: Type.Optional(Type.String()),
+    path: Type.Optional(Type.String()),
+    isDisabled: Type.Optional(Type.Boolean()),
 });
-const xScalarCookiesSchema = Type.Object({
-  "x-scalar-cookies": Type.Optional(Type.Array(xScalarCookieSchema))
+export const xScalarCookiesSchema = Type.Object({
+    'x-scalar-cookies': Type.Optional(Type.Array(xScalarCookieSchema)),
 });
-export {
-  xScalarCookieSchema,
-  xScalarCookiesSchema
-};
-//# sourceMappingURL=x-scalar-cookies.js.map

package/dist/schemas/extensions/general/x-scalar-order.js

@@ -1,8 +1,9 @@
-import { Type } from "@scalar/typebox";
-const XScalarOrderSchema = Type.Object({
-  "x-scalar-order": Type.Optional(Type.Array(Type.String()))
+import { Type } from '@scalar/typebox';
+/**
+ * Schema for the "x-scalar-order" OpenAPI extension.
+ * This extension allows specifying an optional array of strings,
+ * which can be used to represent a custom order for elements (e.g., tags, operations) in the Scalar UI.
+ */
+export const XScalarOrderSchema = Type.Object({
+    'x-scalar-order': Type.Optional(Type.Array(Type.String())),
 });
-export {
-  XScalarOrderSchema
-};
-//# sourceMappingURL=x-scalar-order.js.map

package/dist/schemas/extensions/operation/index.js

@@ -1,23 +1,4 @@
-import {
-  XBadgeSchema,
-  XBadgesSchema
-} from "./x-badge.js";
-import {
-  XCodeSamplesSchema
-} from "./x-code-samples.js";
-import {
-  XScalarSelectedContentTypeSchema
-} from "./x-scalar-selected-content-type.js";
-import {
-  XScalarStabilitySchema,
-  XScalarStabilityValues
-} from "./x-scalar-stability.js";
-export {
-  XBadgeSchema,
-  XBadgesSchema,
-  XCodeSamplesSchema,
-  XScalarSelectedContentTypeSchema,
-  XScalarStabilitySchema,
-  XScalarStabilityValues
-};
-//# sourceMappingURL=index.js.map
+export { XBadgeSchema, XBadgesSchema, } from './x-badge.js';
+export { XCodeSamplesSchema, } from './x-code-samples.js';
+export { XScalarSelectedContentTypeSchema, } from './x-scalar-selected-content-type.js';
+export { XScalarStabilitySchema, XScalarStabilityValues, } from './x-scalar-stability.js';