@nice2dev/ui-graphics 1.3.15 → 1.3.16

package/dist/esm/node_modules/lib0/set.js

@@ -1,9 +1,4 @@
-/**
- * Utility module to work with sets.
- *
- * @module set
- */
-
-const create = () => new Set();
-
-export { create };
+const create = () => /* @__PURE__ */ new Set();
+export {
+  create
+};

package/dist/esm/node_modules/lib0/storage.js

@@ -1,74 +1,43 @@
-/* eslint-env browser */
-
-/**
- * Isomorphic variable storage.
- *
- * Uses LocalStorage in the browser and falls back to in-memory storage.
- *
- * @module storage
- */
-
-/* c8 ignore start */
 class VarStoragePolyfill {
-  constructor () {
-    this.map = new Map();
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
   }
-
   /**
    * @param {string} key
    * @param {any} newValue
    */
-  setItem (key, newValue) {
+  setItem(key, newValue) {
     this.map.set(key, newValue);
   }
-
   /**
    * @param {string} key
    */
-  getItem (key) {
-    return this.map.get(key)
+  getItem(key) {
+    return this.map.get(key);
   }
 }
-/* c8 ignore stop */
-
-/**
- * @type {any}
- */
 let _localStorage = new VarStoragePolyfill();
 let usePolyfill = true;
-
-/* c8 ignore start */
 try {
-  // if the same-origin rule is violated, accessing localStorage might thrown an error
-  if (typeof localStorage !== 'undefined' && localStorage) {
+  if (typeof localStorage !== "undefined" && localStorage) {
     _localStorage = localStorage;
     usePolyfill = false;
   }
-} catch (e) { }
-/* c8 ignore stop */
-
-/**
- * This is basically localStorage in browser, or a polyfill in nodejs
- */
-/* c8 ignore next */
+} catch (e) {
+}
 const varStorage = _localStorage;
-
-/**
- * A polyfill for `addEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
- *
- * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
- * @function
- */
-/* c8 ignore next */
-const onChange = eventHandler => usePolyfill || addEventListener('storage', /** @type {any} */ (eventHandler));
-
-/**
- * A polyfill for `removeEventListener('storage', event => {..})` that does nothing if the polyfill is being used.
- *
- * @param {function({ key: string, newValue: string, oldValue: string }): void} eventHandler
- * @function
- */
-/* c8 ignore next */
-const offChange = eventHandler => usePolyfill || removeEventListener('storage', /** @type {any} */ (eventHandler));
-
-export { offChange, onChange, varStorage };
+const onChange = (eventHandler) => usePolyfill || addEventListener(
+  "storage",
+  /** @type {any} */
+  eventHandler
+);
+const offChange = (eventHandler) => usePolyfill || removeEventListener(
+  "storage",
+  /** @type {any} */
+  eventHandler
+);
+export {
+  offChange,
+  onChange,
+  varStorage
+};

package/dist/esm/node_modules/lib0/string.js

@@ -1,84 +1,39 @@
-import { unfold } from './array.js';
-
-/**
- * Utility module to work with strings.
- *
- * @module string
- */
-
+import { unfold } from "./array.js";
 const fromCharCode = String.fromCharCode;
-
-/**
- * @param {string} s
- * @return {string}
- */
-const toLowerCase = s => s.toLowerCase();
-
+const toLowerCase = (s) => s.toLowerCase();
 const trimLeftRegex = /^\s*/g;
-
-/**
- * @param {string} s
- * @return {string}
- */
-const trimLeft = s => s.replace(trimLeftRegex, '');
-
+const trimLeft = (s) => s.replace(trimLeftRegex, "");
 const fromCamelCaseRegex = /([A-Z])/g;
-
-/**
- * @param {string} s
- * @param {string} separator
- * @return {string}
- */
-const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`));
-
-/**
- * @param {string} str
- * @return {Uint8Array<ArrayBuffer>}
- */
-const _encodeUtf8Polyfill = str => {
+const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, (match) => `${separator}${toLowerCase(match)}`));
+const _encodeUtf8Polyfill = (str) => {
   const encodedString = unescape(encodeURIComponent(str));
   const len = encodedString.length;
   const buf = new Uint8Array(len);
   for (let i = 0; i < len; i++) {
-    buf[i] = /** @type {number} */ (encodedString.codePointAt(i));
+    buf[i] = /** @type {number} */
+    encodedString.codePointAt(i);
   }
-  return buf
+  return buf;
 };
-
-/* c8 ignore next */
-const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
-
-/**
- * @param {string} str
- * @return {Uint8Array<ArrayBuffer>}
- */
-const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
-
-/**
- * @param {string} str
- * @return {Uint8Array}
- */
-/* c8 ignore next */
+const utf8TextEncoder = (
+  /** @type {TextEncoder} */
+  typeof TextEncoder !== "undefined" ? new TextEncoder() : null
+);
+const _encodeUtf8Native = (str) => utf8TextEncoder.encode(str);
 const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
-
-/* c8 ignore next */
-let utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
-
-/* c8 ignore start */
+let utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
-  // Safari doesn't handle BOM correctly.
-  // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.
-  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and
-  // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call
-  // Another issue is that from then on no BOM chars are recognized anymore
-  /* c8 ignore next */
   utf8TextDecoder = null;
 }
-
-/**
- * @param {string} source
- * @param {number} n
- */
-const repeat = (source, n) => unfold(n, () => source).join('');
-
-export { _encodeUtf8Native, _encodeUtf8Polyfill, encodeUtf8, fromCamelCase, fromCharCode, repeat, trimLeft, utf8TextDecoder, utf8TextEncoder };
+const repeat = (source, n) => unfold(n, () => source).join("");
+export {
+  _encodeUtf8Native,
+  _encodeUtf8Polyfill,
+  encodeUtf8,
+  fromCamelCase,
+  fromCharCode,
+  repeat,
+  trimLeft,
+  utf8TextDecoder,
+  utf8TextEncoder
+};

package/dist/esm/node_modules/lib0/symbol.js

@@ -1,12 +1,4 @@
-/**
- * Utility module to work with EcmaScript Symbols.
- *
- * @module symbol
- */
-
-/**
- * Return fresh symbol.
- */
 const create = Symbol;
-
-export { create };
+export {
+  create
+};

package/dist/esm/node_modules/lib0/time.js

@@ -1,15 +1,4 @@
-/**
- * Utility module to work with time.
- *
- * @module time
- */
-
-
-/**
- * Return current unix time.
- *
- * @return {number}
- */
 const getUnixTime = Date.now;
-
-export { getUnixTime };
+export {
+  getUnixTime
+};

package/dist/esm/node_modules/lib0/trait/equality.js

@@ -1,28 +1,6 @@
-const EqualityTraitSymbol = Symbol('Equality');
-
-/**
- * @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait
- */
-
-/**
- *
- * Utility function to compare any two objects.
- *
- * Note that it is expected that the first parameter is more specific than the latter one.
- *
- * @example js
- *     class X { [traits.EqualityTraitSymbol] (other) { return other === this }  }
- *     class X2 { [traits.EqualityTraitSymbol] (other) { return other === this }, x2 () { return 2 }  }
- *     // this is fine
- *     traits.equals(new X2(), new X())
- *     // this is not, because the left type is less specific than the right one
- *     traits.equals(new X(), new X2())
- *
- * @template {EqualityTrait} T
- * @param {NoInfer<T>} a
- * @param {T} b
- * @return {boolean}
- */
+const EqualityTraitSymbol = Symbol("Equality");
 const equals = (a, b) => a === b || !!a?.[EqualityTraitSymbol]?.(b) || false;
-
-export { EqualityTraitSymbol, equals };
+export {
+  EqualityTraitSymbol,
+  equals
+};

package/dist/esm/node_modules/lib0/url.js

@@ -1,17 +1,5 @@
-import { map } from './object.js';
-
-/**
- * Utility module to work with urls.
- *
- * @module url
- */
-
-
-/**
- * @param {Object<string,string>} params
- * @return {string}
- */
-const encodeQueryParams = params =>
-  map(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join('&');
-
-export { encodeQueryParams };
+import { map } from "./object.js";
+const encodeQueryParams = (params) => map(params, (val, key) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`).join("&");
+export {
+  encodeQueryParams
+};

package/dist/esm/node_modules/lib0/webcrypto.js

@@ -1,5 +1,4 @@
-/* eslint-env browser */
-
 const getRandomValues = crypto.getRandomValues.bind(crypto);
-
-export { getRandomValues };
+export {
+  getRandomValues
+};

package/dist/esm/node_modules/y-protocols/auth.js

@@ -1,23 +1,12 @@
-import { readVarUint, readVarString } from '../lib0/decoding.js';
-
+import { readVarUint, readVarString } from "../lib0/decoding.js";
 const messagePermissionDenied = 0;
-
-/**
- * @callback PermissionDeniedHandler
- * @param {any} y
- * @param {string} reason
- */
-
-/**
- *
- * @param {decoding.Decoder} decoder
- * @param {Y.Doc} y
- * @param {PermissionDeniedHandler} permissionDeniedHandler
- */
 const readAuthMessage = (decoder, y, permissionDeniedHandler) => {
   switch (readVarUint(decoder)) {
-    case messagePermissionDenied: permissionDeniedHandler(y, readVarString(decoder));
+    case messagePermissionDenied:
+      permissionDeniedHandler(y, readVarString(decoder));
   }
 };
-
-export { messagePermissionDenied, readAuthMessage };
+export {
+  messagePermissionDenied,
+  readAuthMessage
+};

package/dist/esm/node_modules/y-protocols/awareness.js

@@ -1,70 +1,27 @@
-import { writeVarUint, writeVarString, toUint8Array, createEncoder } from '../lib0/encoding.js';
-import { readVarUint, readVarString, createDecoder } from '../lib0/decoding.js';
-import { getUnixTime } from '../lib0/time.js';
-import { floor } from '../lib0/math.js';
-import { Observable } from '../lib0/observable.js';
-import { equalityDeep } from '../lib0/function.js';
-
-/**
- * @module awareness-protocol
- */
-
-
-const outdatedTimeout = 30000;
-
-/**
- * @typedef {Object} MetaClientState
- * @property {number} MetaClientState.clock
- * @property {number} MetaClientState.lastUpdated unix timestamp
- */
-
-/**
- * The Awareness class implements a simple shared state protocol that can be used for non-persistent data like awareness information
- * (cursor, username, status, ..). Each client can update its own local state and listen to state changes of
- * remote clients. Every client may set a state of a remote peer to `null` to mark the client as offline.
- *
- * Each client is identified by a unique client id (something we borrow from `doc.clientID`). A client can override
- * its own state by propagating a message with an increasing timestamp (`clock`). If such a message is received, it is
- * applied if the known state of that client is older than the new state (`clock < newClock`). If a client thinks that
- * a remote client is offline, it may propagate a message with
- * `{ clock: currentClientClock, state: null, client: remoteClient }`. If such a
- * message is received, and the known clock of that client equals the received clock, it will override the state with `null`.
- *
- * Before a client disconnects, it should propagate a `null` state with an updated clock.
- *
- * Awareness states must be updated every 30 seconds. Otherwise the Awareness instance will delete the client state.
- *
- * @extends {Observable<string>}
- */
+import { writeVarUint, writeVarString, toUint8Array, createEncoder } from "../lib0/encoding.js";
+import { readVarUint, readVarString, createDecoder } from "../lib0/decoding.js";
+import { getUnixTime } from "../lib0/time.js";
+import { floor } from "../lib0/math.js";
+import { Observable } from "../lib0/observable.js";
+import { equalityDeep } from "../lib0/function.js";
+const outdatedTimeout = 3e4;
 class Awareness extends Observable {
   /**
    * @param {Y.Doc} doc
    */
-  constructor (doc) {
+  constructor(doc) {
     super();
     this.doc = doc;
-    /**
-     * @type {number}
-     */
     this.clientID = doc.clientID;
-    /**
-     * Maps from client id to client state
-     * @type {Map<number, Object<string, any>>}
-     */
-    this.states = new Map();
-    /**
-     * @type {Map<number, MetaClientState>}
-     */
-    this.meta = new Map();
-    this._checkInterval = /** @type {any} */ (setInterval(() => {
+    this.states = /* @__PURE__ */ new Map();
+    this.meta = /* @__PURE__ */ new Map();
+    this._checkInterval = /** @type {any} */
+    setInterval(() => {
       const now = getUnixTime();
-      if (this.getLocalState() !== null && (outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */ (this.meta.get(this.clientID)).lastUpdated)) {
-        // renew local clock
+      if (this.getLocalState() !== null && outdatedTimeout / 2 <= now - /** @type {{lastUpdated:number}} */
+      this.meta.get(this.clientID).lastUpdated) {
         this.setLocalState(this.getLocalState());
       }
-      /**
-       * @type {Array<number>}
-       */
       const remove = [];
       this.meta.forEach((meta, clientid) => {
         if (clientid !== this.clientID && outdatedTimeout <= now - meta.lastUpdated && this.states.has(clientid)) {
@@ -72,36 +29,33 @@ class Awareness extends Observable {
         }
       });
       if (remove.length > 0) {
-        removeAwarenessStates(this, remove, 'timeout');
+        removeAwarenessStates(this, remove, "timeout");
       }
-    }, floor(outdatedTimeout / 10)));
-    doc.on('destroy', () => {
+    }, floor(outdatedTimeout / 10));
+    doc.on("destroy", () => {
       this.destroy();
     });
     this.setLocalState({});
   }
-
-  destroy () {
-    this.emit('destroy', [this]);
+  destroy() {
+    this.emit("destroy", [this]);
     this.setLocalState(null);
     super.destroy();
     clearInterval(this._checkInterval);
   }
-
   /**
    * @return {Object<string,any>|null}
    */
-  getLocalState () {
-    return this.states.get(this.clientID) || null
+  getLocalState() {
+    return this.states.get(this.clientID) || null;
   }
-
   /**
    * @param {Object<string,any>|null} state
    */
-  setLocalState (state) {
+  setLocalState(state) {
     const clientID = this.clientID;
     const currLocalMeta = this.meta.get(clientID);
-    const clock = currLocalMeta === undefined ? 0 : currLocalMeta.clock + 1;
+    const clock = currLocalMeta === void 0 ? 0 : currLocalMeta.clock + 1;
     const prevState = this.states.get(clientID);
     if (state === null) {
       this.states.delete(clientID);
@@ -129,16 +83,15 @@ class Awareness extends Observable {
       }
     }
     if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
-      this.emit('change', [{ added, updated: filteredUpdated, removed }, 'local']);
+      this.emit("change", [{ added, updated: filteredUpdated, removed }, "local"]);
     }
-    this.emit('update', [{ added, updated, removed }, 'local']);
+    this.emit("update", [{ added, updated, removed }, "local"]);
   }
-
   /**
    * @param {string} field
    * @param {any} value
    */
-  setLocalStateField (field, value) {
+  setLocalStateField(field, value) {
     const state = this.getLocalState();
     if (state !== null) {
       this.setLocalState({
@@ -147,23 +100,13 @@ class Awareness extends Observable {
       });
     }
   }
-
   /**
    * @return {Map<number,Object<string,any>>}
    */
-  getStates () {
-    return this.states
+  getStates() {
+    return this.states;
   }
 }
-
-/**
- * Mark (remote) clients as inactive and remove them from the list of active peers.
- * This change will be propagated to remote clients.
- *
- * @param {Awareness} awareness
- * @param {Array<number>} clients
- * @param {any} origin
- */
 const removeAwarenessStates = (awareness, clients, origin) => {
   const removed = [];
   for (let i = 0; i < clients.length; i++) {
@@ -171,7 +114,10 @@ const removeAwarenessStates = (awareness, clients, origin) => {
     if (awareness.states.has(clientID)) {
       awareness.states.delete(clientID);
       if (clientID === awareness.clientID) {
-        const curMeta = /** @type {MetaClientState} */ (awareness.meta.get(clientID));
+        const curMeta = (
+          /** @type {MetaClientState} */
+          awareness.meta.get(clientID)
+        );
         awareness.meta.set(clientID, {
           clock: curMeta.clock + 1,
           lastUpdated: getUnixTime()
@@ -181,16 +127,10 @@ const removeAwarenessStates = (awareness, clients, origin) => {
     }
   }
   if (removed.length > 0) {
-    awareness.emit('change', [{ added: [], updated: [], removed }, origin]);
-    awareness.emit('update', [{ added: [], updated: [], removed }, origin]);
+    awareness.emit("change", [{ added: [], updated: [], removed }, origin]);
+    awareness.emit("update", [{ added: [], updated: [], removed }, origin]);
   }
 };
-
-/**
- * @param {Awareness} awareness
- * @param {Array<number>} clients
- * @return {Uint8Array}
- */
 const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
   const len = clients.length;
   const encoder = createEncoder();
@@ -198,19 +138,16 @@ const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) =>
   for (let i = 0; i < len; i++) {
     const clientID = clients[i];
     const state = states.get(clientID) || null;
-    const clock = /** @type {MetaClientState} */ (awareness.meta.get(clientID)).clock;
+    const clock = (
+      /** @type {MetaClientState} */
+      awareness.meta.get(clientID).clock
+    );
     writeVarUint(encoder, clientID);
     writeVarUint(encoder, clock);
     writeVarString(encoder, JSON.stringify(state));
   }
-  return toUint8Array(encoder)
+  return toUint8Array(encoder);
 };
-
-/**
- * @param {Awareness} awareness
- * @param {Uint8Array} update
- * @param {any} origin This will be added to the emitted change event
- */
 const applyAwarenessUpdate = (awareness, update, origin) => {
   const decoder = createDecoder(update);
   const timestamp = getUnixTime();
@@ -225,13 +162,10 @@ const applyAwarenessUpdate = (awareness, update, origin) => {
     const state = JSON.parse(readVarString(decoder));
     const clientMeta = awareness.meta.get(clientID);
     const prevState = awareness.states.get(clientID);
-    const currClock = clientMeta === undefined ? 0 : clientMeta.clock;
-    if (currClock < clock || (currClock === clock && state === null && awareness.states.has(clientID))) {
+    const currClock = clientMeta === void 0 ? 0 : clientMeta.clock;
+    if (currClock < clock || currClock === clock && state === null && awareness.states.has(clientID)) {
       if (state === null) {
-        // never let a remote client remove this local state
         if (clientID === awareness.clientID && awareness.getLocalState() != null) {
-          // remote client removed the local state. Do not remote state. Broadcast a message indicating
-          // that this client still exists by increasing the clock
           clock++;
         } else {
           awareness.states.delete(clientID);
@@ -243,9 +177,9 @@ const applyAwarenessUpdate = (awareness, update, origin) => {
         clock,
         lastUpdated: timestamp
       });
-      if (clientMeta === undefined && state !== null) {
+      if (clientMeta === void 0 && state !== null) {
         added.push(clientID);
-      } else if (clientMeta !== undefined && state === null) {
+      } else if (clientMeta !== void 0 && state === null) {
         removed.push(clientID);
       } else if (state !== null) {
         if (!equalityDeep(state, prevState)) {
@@ -256,15 +190,24 @@ const applyAwarenessUpdate = (awareness, update, origin) => {
     }
   }
   if (added.length > 0 || filteredUpdated.length > 0 || removed.length > 0) {
-    awareness.emit('change', [{
-      added, updated: filteredUpdated, removed
+    awareness.emit("change", [{
+      added,
+      updated: filteredUpdated,
+      removed
     }, origin]);
   }
   if (added.length > 0 || updated.length > 0 || removed.length > 0) {
-    awareness.emit('update', [{
-      added, updated, removed
+    awareness.emit("update", [{
+      added,
+      updated,
+      removed
     }, origin]);
   }
 };
-
-export { Awareness, applyAwarenessUpdate, encodeAwarenessUpdate, outdatedTimeout, removeAwarenessStates };
+export {
+  Awareness,
+  applyAwarenessUpdate,
+  encodeAwarenessUpdate,
+  outdatedTimeout,
+  removeAwarenessStates
+};