@scalar/workspace-store 0.40.2 → 0.40.4

package/dist/entities/history/schema.js

@@ -1,99 +1,105 @@
-import { Type } from "@scalar/typebox";
+import { Type } from '@scalar/typebox';
 const HeaderSchema = Type.Object({
-  name: Type.String(),
-  value: Type.String()
+    name: Type.String(),
+    value: Type.String(),
 });
+/**
+ * This object contains detailed info about performed request.
+ */
 const RequestSchema = Type.Object({
-  /** Absolute URL of the request (fragments are not included). */
-  url: Type.String(),
-  /** Request method (`GET`, `POST`, ...). */
-  method: Type.String(),
-  /** Request HTTP Version. */
-  httpVersion: Type.String(),
-  /** List of header objects. */
-  headers: Type.Array(HeaderSchema),
-  /** List of cookie objects. */
-  cookies: Type.Array(HeaderSchema),
-  /**
-   * Total number of bytes from the start of the HTTP request message until
-   * (and including) the double CRLF before the body.
-   *
-   * Set to `-1` if the info is not available.
-   */
-  headersSize: Type.Number(),
-  /** List of query string objects. */
-  queryString: Type.Array(HeaderSchema),
-  /**
-   * Size of the request body (POST data payload) in bytes.
-   *
-   * Set to `-1` if the info is not available.
-   */
-  bodySize: Type.Number(),
-  /** Posted data info. */
-  postData: Type.Optional(
-    Type.Union([
-      Type.Object({
-        /** Mime type of posted data. */
-        mimeType: Type.String(),
-        text: Type.String()
-      }),
-      Type.Object({
-        /** Mime type of posted data. */
-        mimeType: Type.String(),
-        params: Type.Array(Type.Object({ name: Type.String(), value: Type.Optional(Type.String()) }))
-      })
-    ])
-  )
+    /** Absolute URL of the request (fragments are not included). */
+    url: Type.String(),
+    /** Request method (`GET`, `POST`, ...). */
+    method: Type.String(),
+    /** Request HTTP Version. */
+    httpVersion: Type.String(),
+    /** List of header objects. */
+    headers: Type.Array(HeaderSchema),
+    /** List of cookie objects. */
+    cookies: Type.Array(HeaderSchema),
+    /**
+     * Total number of bytes from the start of the HTTP request message until
+     * (and including) the double CRLF before the body.
+     *
+     * Set to `-1` if the info is not available.
+     */
+    headersSize: Type.Number(),
+    /** List of query string objects. */
+    queryString: Type.Array(HeaderSchema),
+    /**
+     * Size of the request body (POST data payload) in bytes.
+     *
+     * Set to `-1` if the info is not available.
+     */
+    bodySize: Type.Number(),
+    /** Posted data info. */
+    postData: Type.Optional(Type.Union([
+        Type.Object({
+            /** Mime type of posted data. */
+            mimeType: Type.String(),
+            text: Type.String(),
+        }),
+        Type.Object({
+            /** Mime type of posted data. */
+            mimeType: Type.String(),
+            params: Type.Array(Type.Object({ name: Type.String(), value: Type.Optional(Type.String()) })),
+        }),
+    ])),
 });
 const ResponseSchema = Type.Object({
-  status: Type.Number(),
-  statusText: Type.String(),
-  headers: Type.Array(HeaderSchema),
-  cookies: Type.Array(HeaderSchema),
-  httpVersion: Type.String(),
-  redirectURL: Type.String(),
-  headersSize: Type.Number(),
-  bodySize: Type.Number(),
-  content: Type.Object({
-    size: Type.Number(),
-    mimeType: Type.String(),
-    encoding: Type.Optional(Type.String()),
-    text: Type.Optional(Type.String())
-  })
+    status: Type.Number(),
+    statusText: Type.String(),
+    headers: Type.Array(HeaderSchema),
+    cookies: Type.Array(HeaderSchema),
+    httpVersion: Type.String(),
+    redirectURL: Type.String(),
+    headersSize: Type.Number(),
+    bodySize: Type.Number(),
+    content: Type.Object({
+        size: Type.Number(),
+        mimeType: Type.String(),
+        encoding: Type.Optional(Type.String()),
+        text: Type.Optional(Type.String()),
+    }),
 });
 const HistoryEntrySchema = Type.Object({
-  /**
-   * Total elapsed time of the request in milliseconds.
-   *
-   * This is the sum of all timings available in the timings object
-   * (i.e. not including `-1` values).
-   */
-  time: Type.Number(),
-  /** Timestamp of the request. */
-  timestamp: Type.Number(),
-  /** Detailed info about the request. */
-  request: RequestSchema,
-  /** Detailed info about the response. */
-  response: ResponseSchema,
-  /** Meta data about the request. */
-  meta: Type.Object({
-    /** The example key for the request. */
-    example: Type.String()
-  }),
-  requestMetadata: Type.Object({
-    /** Variables used in the request.
+    /**
+     * Total elapsed time of the request in milliseconds.
      *
-     * Since HAR format does not support variables, we need to store them here.
-     * This way we can easily re-use the request with the same variables.
-     * We don't need to do any server + variables matching and replacement.
+     * This is the sum of all timings available in the timings object
+     * (i.e. not including `-1` values).
      */
-    variables: Type.Record(Type.String(), Type.String())
-    // Other meta fields (e.g., server) can be added here in the future.
-  })
+    time: Type.Number(),
+    /** Timestamp of the request. */
+    timestamp: Type.Number(),
+    /** Detailed info about the request. */
+    request: RequestSchema,
+    /** Detailed info about the response. */
+    response: ResponseSchema,
+    /** Meta data about the request. */
+    meta: Type.Object({
+        /** The example key for the request. */
+        example: Type.String(),
+    }),
+    requestMetadata: Type.Object({
+        /** Variables used in the request.
+         *
+         * Since HAR format does not support variables, we need to store them here.
+         * This way we can easily re-use the request with the same variables.
+         * We don't need to do any server + variables matching and replacement.
+         */
+        variables: Type.Record(Type.String(), Type.String()),
+        // Other meta fields (e.g., server) can be added here in the future.
+    }),
 });
+/**
+ * Schema for the path method history.
+ *
+ * {
+ *   "path": {
+ *     "method": [Entry]
+ *   }
+ * }
+ */
 const PathMethodHistorySchema = Type.Record(Type.String(), Type.Record(Type.String(), Type.Array(HistoryEntrySchema)));
-const DocumentHistorySchema = Type.Record(Type.String(), PathMethodHistorySchema);
-export {
-  DocumentHistorySchema
-};
-//# sourceMappingURL=schema.js.map
+export const DocumentHistorySchema = Type.Record(Type.String(), PathMethodHistorySchema);

package/dist/events/bus.js

@@ -1,96 +1,149 @@
-import { debounce } from "@scalar/helpers/general/debounce";
-import { unpackProxyObject } from "../helpers/unpack-proxy.js";
-const createWorkspaceEventBus = (options = {}) => {
-  const { debug = false } = options;
-  const events = /* @__PURE__ */ new Map();
-  const pendingLogs = [];
-  let logTimeout = null;
-  const { execute: debouncedEmitter } = debounce({ delay: 328 });
-  const getListeners = (event) => {
-    const listeners = events.get(event) ?? /* @__PURE__ */ new Set();
-    events.set(event, listeners);
-    return listeners;
-  };
-  const flushLogs = () => {
-    if (pendingLogs.length === 0) {
-      return;
-    }
-    if (debug) {
-      if (pendingLogs.length === 1) {
-        const firstLog = pendingLogs[0];
-        if (firstLog) {
-          console.log(`[EventBus] ${firstLog.message}`, ...firstLog.args);
+import { debounce } from '@scalar/helpers/general/debounce';
+import { unpackProxyObject } from '../helpers/unpack-proxy.js';
+/**
+ * Creates a type-safe event bus for workspace events
+ *
+ * This implementation uses a Map for O(1) lookups and maintains
+ * a separate Set for each event type to efficiently manage listeners.
+ *
+ * Create this once per application instance.
+ *
+ * @param options - Configuration options
+ * @returns A fully type-safe event bus instance
+ *
+ * @example
+ * const bus = createWorkspaceEventBus()
+ *
+ * // Subscribe to events
+ * const unsubscribe = bus.on('scalar-update-sidebar', (detail) => {
+ *   console.log('Sidebar:', detail.value)
+ * })
+ *
+ * // Emit events
+ * bus.emit('scalar-update-sidebar', { value: true })
+ *
+ * // Clean up
+ * unsubscribe()
+ */
+export const createWorkspaceEventBus = (options = {}) => {
+    const { debug = false } = options;
+    const events = new Map();
+    const pendingLogs = [];
+    let logTimeout = null;
+    /**
+     * Single debounce instance for all debounced emits
+     * Uses keys to separate different event + debounceKey combinations
+     */
+    const { execute: debouncedEmitter } = debounce({ delay: 328 });
+    /**
+     * Get or create a listener set for an event
+     */
+    const getListeners = (event) => {
+        const listeners = events.get(event) ?? new Set();
+        events.set(event, listeners);
+        return listeners;
+    };
+    /**
+     * Flush batched logs using console.groupCollapsed
+     */
+    const flushLogs = () => {
+        if (pendingLogs.length === 0) {
+            return;
         }
-      } else {
-        console.groupCollapsed(`[EventBus] ${pendingLogs.length} operations`);
-        for (const { message, args } of pendingLogs) {
-          console.log(message, ...args);
+        if (debug) {
+            if (pendingLogs.length === 1) {
+                // Only one log, output it normally without grouping
+                const firstLog = pendingLogs[0];
+                if (firstLog) {
+                    console.log(`[EventBus] ${firstLog.message}`, ...firstLog.args);
+                }
+            }
+            else {
+                // Multiple logs, use a collapsed group
+                console.groupCollapsed(`[EventBus] ${pendingLogs.length} operations`);
+                for (const { message, args } of pendingLogs) {
+                    console.log(message, ...args);
+                }
+                console.groupEnd();
+            }
         }
-        console.groupEnd();
-      }
-    }
-    pendingLogs.length = 0;
-    logTimeout = null;
-  };
-  const log = (message, ...args) => {
-    if (debug) {
-      pendingLogs.push({ message, args });
-      if (logTimeout) {
-        clearTimeout(logTimeout);
-      }
-      logTimeout = setTimeout(flushLogs, 500);
-    }
-  };
-  const on = (event, listener) => {
-    const listeners = getListeners(event);
-    listeners.add(listener);
-    log(`Added listener for "${String(event)}" (${listeners.size} total)`);
-    return () => off(event, listener);
-  };
-  const off = (event, listener) => {
-    const listeners = events.get(event);
-    if (!listeners) {
-      return;
-    }
-    listeners.delete(listener);
-    log(`Removed listener for "${String(event)}" (${listeners.size} remaining)`);
-    if (listeners.size === 0) {
-      events.delete(event);
-    }
-  };
-  const performEmit = (event, payload, options2) => {
-    const unpackedPayload = options2?.skipUnpackProxy ? payload : unpackProxyObject(payload, { depth: 5 });
-    const listeners = events.get(event);
-    if (!listeners || listeners.size === 0) {
-      log(`\u{1F6D1} No listeners for "${String(event)}"`);
-      return;
-    }
-    log(`Emitting "${String(event)}" to ${listeners.size} listener(s)`, payload);
-    const listenersArray = Array.from(listeners);
-    for (const listener of listenersArray) {
-      try {
-        listener(unpackedPayload);
-      } catch (error) {
-        console.error(`[EventBus] Error in listener for "${String(event)}":`, error);
-      }
-    }
-  };
-  const emit = (...args) => {
-    const [event, payload, options2] = args;
-    if (!options2?.debounceKey) {
-      performEmit(event, payload, options2);
-      return;
-    }
-    const debounceMapKey = `${event}-${options2.debounceKey}`;
-    debouncedEmitter(debounceMapKey, () => performEmit(event, payload, options2));
-  };
-  return {
-    on,
-    off,
-    emit
-  };
-};
-export {
-  createWorkspaceEventBus
+        pendingLogs.length = 0;
+        logTimeout = null;
+    };
+    /**
+     * Log debug information if debug mode is enabled
+     * Batches multiple logs together using console.groupCollapsed
+     */
+    const log = (message, ...args) => {
+        if (debug) {
+            pendingLogs.push({ message, args });
+            // Clear existing timeout and set a new one to batch logs
+            if (logTimeout) {
+                clearTimeout(logTimeout);
+            }
+            logTimeout = setTimeout(flushLogs, 500);
+        }
+    };
+    const on = (event, listener) => {
+        const listeners = getListeners(event);
+        listeners.add(listener);
+        log(`Added listener for "${String(event)}" (${listeners.size} total)`);
+        return () => off(event, listener);
+    };
+    const off = (event, listener) => {
+        const listeners = events.get(event);
+        if (!listeners) {
+            return;
+        }
+        listeners.delete(listener);
+        log(`Removed listener for "${String(event)}" (${listeners.size} remaining)`);
+        // Clean up empty listener sets to avoid memory leaks
+        if (listeners.size === 0) {
+            events.delete(event);
+        }
+    };
+    /**
+     * Internal function that performs the actual emission logic
+     * This is extracted so it can be wrapped with debouncing
+     */
+    const performEmit = (event, payload, options) => {
+        // We unpack the payload here to ensure that, within mutators, we are not assigning proxies directly,
+        // but are always assigning plain objects 5 level depth.
+        const unpackedPayload = options?.skipUnpackProxy ? payload : unpackProxyObject(payload, { depth: 5 });
+        const listeners = events.get(event);
+        if (!listeners || listeners.size === 0) {
+            log(`🛑 No listeners for "${String(event)}"`);
+            return;
+        }
+        log(`Emitting "${String(event)}" to ${listeners.size} listener(s)`, payload);
+        // Convert to array to avoid issues if listeners modify the set during iteration
+        const listenersArray = Array.from(listeners);
+        // Execute all listeners
+        for (const listener of listenersArray) {
+            try {
+                listener(unpackedPayload);
+            }
+            catch (error) {
+                // Do not let one listener error break other listeners
+                console.error(`[EventBus] Error in listener for "${String(event)}":`, error);
+            }
+        }
+    };
+    const emit = (...args) => {
+        const [event, payload, options] = args;
+        // If no debounce key is provided, emit immediately
+        if (!options?.debounceKey) {
+            performEmit(event, payload, options);
+            return;
+        }
+        // Create a unique key for this event + debounce key combination
+        const debounceMapKey = `${event}-${options.debounceKey}`;
+        // Pass the closure directly - debounce will store the latest version
+        debouncedEmitter(debounceMapKey, () => performEmit(event, payload, options));
+    };
+    return {
+        on,
+        off,
+        emit,
+    };
 };
-//# sourceMappingURL=bus.js.map

package/dist/events/definitions/analytics.js

@@ -1 +1 @@
-//# sourceMappingURL=analytics.js.map
+export {};

package/dist/events/definitions/auth.js

@@ -1 +1 @@
-//# sourceMappingURL=auth.js.map
+export {};

package/dist/events/definitions/common.js

@@ -1 +1 @@
-//# sourceMappingURL=common.js.map
+export {};

package/dist/events/definitions/cookie.js

@@ -1 +1 @@
-//# sourceMappingURL=cookie.js.map
+export {};

package/dist/events/definitions/document.js

@@ -1 +1 @@
-//# sourceMappingURL=document.js.map
+export {};

package/dist/events/definitions/environment.js

@@ -1 +1 @@
-//# sourceMappingURL=environment.js.map
+export {};

package/dist/events/definitions/hooks.js

@@ -1 +1 @@
-//# sourceMappingURL=hooks.js.map
+export {};

package/dist/events/definitions/index.js

@@ -1 +1 @@
-//# sourceMappingURL=index.js.map
+export {};

package/dist/events/definitions/meta.js

@@ -1 +1 @@
-//# sourceMappingURL=meta.js.map
+export {};

package/dist/events/definitions/operation.js

@@ -1 +1 @@
-//# sourceMappingURL=operation.js.map
+export {};

package/dist/events/definitions/server.js

@@ -1 +1 @@
-//# sourceMappingURL=server.js.map
+export {};

package/dist/events/definitions/tabs.js

@@ -1 +1 @@
-//# sourceMappingURL=tabs.js.map
+export {};

package/dist/events/definitions/tag.js

@@ -1 +1 @@
-//# sourceMappingURL=tag.js.map
+export {};

package/dist/events/definitions/ui.js

@@ -1 +1 @@
-//# sourceMappingURL=ui.js.map
+export {};

package/dist/events/definitions/workspace.js

@@ -1 +1 @@
-//# sourceMappingURL=workspace.js.map
+export {};

package/dist/events/index.js

@@ -1,9 +1,3 @@
-import { createWorkspaceEventBus } from "./bus.js";
-import { onCustomEvent } from "./listeners.js";
-import { emitCustomEvent } from "./old-definitions.js";
-export {
-  createWorkspaceEventBus,
-  emitCustomEvent,
-  onCustomEvent
-};
-//# sourceMappingURL=index.js.map
+export { createWorkspaceEventBus } from './bus.js';
+export { onCustomEvent } from './listeners.js';
+export { emitCustomEvent } from './old-definitions.js';

package/dist/events/listeners.js

@@ -1,23 +1,21 @@
-import { onBeforeUnmount, watch } from "vue";
-function onCustomEvent(el, event, handler) {
-  watch(
-    () => el.value,
-    (element) => {
-      if (!element) {
-        return;
-      }
-      element.addEventListener(event, handler);
-    },
-    { immediate: true }
-  );
-  onBeforeUnmount(() => {
-    if (!el.value) {
-      return;
-    }
-    el.value.removeEventListener(event, handler);
-  });
+import { onBeforeUnmount, watch } from 'vue';
+/**
+ * Vue wrapper for attaching and removing event listeners
+ *
+ * @deprecated Use the the event bus instead
+ */
+export function onCustomEvent(el, event, handler) {
+    // Any time the element reference changes, we need to add the event listener
+    watch(() => el.value, (element) => {
+        if (!element) {
+            return;
+        }
+        element.addEventListener(event, handler);
+    }, { immediate: true });
+    onBeforeUnmount(() => {
+        if (!el.value) {
+            return;
+        }
+        el.value.removeEventListener(event, handler);
+    });
 }
-export {
-  onCustomEvent
-};
-//# sourceMappingURL=listeners.js.map

package/dist/events/old-definitions.js

@@ -1,13 +1,16 @@
-function emitCustomEvent(target, event, detail) {
-  const instance = new CustomEvent(event, {
-    detail,
-    bubbles: true,
-    composed: true,
-    cancelable: true
-  });
-  target?.dispatchEvent(instance);
+/**
+ * Scalar blocks will use vanilla events to allow more flexibility in integrations
+ *
+ * Event can include typed payloads using the `data` property. A target for the dispatch must be provided.
+ *
+ * @deprecated Use the the event bus instead
+ */
+export function emitCustomEvent(target, event, detail) {
+    const instance = new CustomEvent(event, {
+        detail: detail,
+        bubbles: true,
+        composed: true,
+        cancelable: true,
+    });
+    target?.dispatchEvent(instance);
 }
-export {
-  emitCustomEvent
-};
-//# sourceMappingURL=old-definitions.js.map

package/dist/helpers/deep-clone.js

@@ -1,18 +1,34 @@
-const deepClone = (value, hash = /* @__PURE__ */ new WeakMap()) => {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  if (hash.has(value)) {
-    return hash.get(value);
-  }
-  const result = Array.isArray(value) ? [] : {};
-  hash.set(value, result);
-  Object.keys(value).forEach((key) => {
-    result[key] = deepClone(value[key], hash);
-  });
-  return result;
+/**
+ * Deeply clones an object or array, handling circular references.
+ *
+ * This function recursively copies all properties of the input value,
+ * creating a new object or array. If the input contains circular references,
+ * they are preserved in the clone using a WeakMap to track already-cloned objects.
+ *
+ * @param value - The value to deep clone (object, array, or primitive)
+ * @param hash - (internal) WeakMap for tracking circular references
+ * @returns A deep clone of the input value
+ *
+ * @example
+ * const obj: any = { a: 1 }
+ * obj.self = obj
+ * const clone = deepClone(obj)
+ * console.log(clone) // { a: 1, self: [Circular] }
+ * console.log(clone !== obj) // true
+ * console.log(clone.self === clone) // true
+ */
+export const deepClone = (value, hash = new WeakMap()) => {
+    if (typeof value !== 'object' || value === null) {
+        return value;
+    }
+    if (hash.has(value)) {
+        return hash.get(value);
+    }
+    const result = Array.isArray(value) ? [] : {};
+    hash.set(value, result);
+    Object.keys(value).forEach((key) => {
+        // @ts-expect-error: Index signature for generic object
+        result[key] = deepClone(value[key], hash);
+    });
+    return result;
 };
-export {
-  deepClone
-};
-//# sourceMappingURL=deep-clone.js.map