ivt 0.5.1 → 0.5.2

package/dist/carousel/index.mjs

@@ -1,9 +1,9 @@
 import * as React from 'react';
 import { useRef, useState, useCallback, useEffect } from 'react';
-import { c as cn } from '../chunks/utils-D0vBZFbG.mjs';
-import { c as createLucideIcon } from '../chunks/createLucideIcon-7URJZQ6y.mjs';
-import { B as Button } from '../chunks/button-D-AuR380.mjs';
-import '../chunks/bundle-mjs-hDzYn9Rn.mjs';
+import { c as cn } from '../chunks/utils-DfaTa-5f.mjs';
+import { c as createLucideIcon } from '../chunks/createLucideIcon-rdK7ReAV.mjs';
+import { B as Button } from '../chunks/button-BrmYbiY8.mjs';
+import '../chunks/bundle-mjs-C9OlPgmH.mjs';
 import '@radix-ui/react-slot';
 import 'class-variance-authority';
 

package/dist/chart/index.mjs

@@ -1,10 +1,10 @@
 import * as React from 'react';
 import React__default, { isValidElement, forwardRef, useContext, createContext, PureComponent, useState, useCallback, useMemo, useRef, useImperativeHandle, useEffect, cloneElement, createElement } from 'react';
-import { a as clsx, c as cn } from '../chunks/utils-D0vBZFbG.mjs';
+import { a as clsx, c as cn } from '../chunks/utils-DfaTa-5f.mjs';
 import { createPortal } from 'react-dom';
-import { g as getDefaultExportFromCjs } from '../chunks/_commonjsHelpers-BMPzsb8G.mjs';
-import { r as requireShim } from '../chunks/index-B87WmpPj.mjs';
-import '../chunks/bundle-mjs-hDzYn9Rn.mjs';
+import { g as getDefaultExportFromCjs } from '../chunks/_commonjsHelpers-DCzDIER3.mjs';
+import { r as requireShim } from '../chunks/index-N54PlKgO.mjs';
+import '../chunks/bundle-mjs-C9OlPgmH.mjs';
 
 var EventKeys = [
     'dangerouslySetInnerHTML',
@@ -4361,19 +4361,25 @@ function isDraftable(value) {
     return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
 }
 var objectCtorString = Object.prototype.constructor.toString();
+var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
 function isPlainObject(value) {
     if (!value || typeof value !== "object") return false;
-    const proto = getPrototypeOf(value);
-    if (proto === null) {
-        return true;
-    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null || proto === Object.prototype) return true;
     const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
     if (Ctor === Object) return true;
-    return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+    if (typeof Ctor !== "function") return false;
+    let ctorString = cachedCtorStrings.get(Ctor);
+    if (ctorString === void 0) {
+        ctorString = Function.toString.call(Ctor);
+        cachedCtorStrings.set(Ctor, ctorString);
+    }
+    return ctorString === objectCtorString;
 }
-function each(obj, iter) {
+function each(obj, iter, strict = true) {
     if (getArchtype(obj) === 0 /* Object */ ) {
-        Reflect.ownKeys(obj).forEach((key)=>{
+        const keys = strict ? Reflect.ownKeys(obj) : Object.keys(obj);
+        keys.forEach((key)=>{
             iter(key, obj[key], obj);
         });
     } else {
@@ -4454,18 +4460,10 @@ function freeze(obj, deep = false) {
     if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj;
     if (getArchtype(obj) > 1) {
         Object.defineProperties(obj, {
-            set: {
-                value: dontMutateFrozenCollections
-            },
-            add: {
-                value: dontMutateFrozenCollections
-            },
-            clear: {
-                value: dontMutateFrozenCollections
-            },
-            delete: {
-                value: dontMutateFrozenCollections
-            }
+            set: dontMutateMethodOverride,
+            add: dontMutateMethodOverride,
+            clear: dontMutateMethodOverride,
+            delete: dontMutateMethodOverride
         });
     }
     Object.freeze(obj);
@@ -4475,7 +4473,11 @@ function freeze(obj, deep = false) {
 function dontMutateFrozenCollections() {
     die(2);
 }
+var dontMutateMethodOverride = {
+    value: dontMutateFrozenCollections
+};
 function isFrozen(obj) {
+    if (obj === null || typeof obj !== "object") return true;
     return Object.isFrozen(obj);
 }
 // src/utils/plugins.ts
@@ -4557,9 +4559,10 @@ function processResult(result, scope) {
 }
 function finalize(rootScope, value, path) {
     if (isFrozen(value)) return value;
+    const useStrictIteration = rootScope.immer_.shouldUseStrictIteration();
     const state = value[DRAFT_STATE];
     if (!state) {
-        each(value, (key, childValue)=>finalizeProperty(rootScope, state, value, key, childValue, path));
+        each(value, (key, childValue)=>finalizeProperty(rootScope, state, value, key, childValue, path), useStrictIteration);
         return value;
     }
     if (state.scope_ !== rootScope) return value;
@@ -4578,7 +4581,7 @@ function finalize(rootScope, value, path) {
             result.clear();
             isSet2 = true;
         }
-        each(resultEach, (key, childValue)=>finalizeProperty(rootScope, state, result, key, childValue, path, isSet2));
+        each(resultEach, (key, childValue)=>finalizeProperty(rootScope, state, result, key, childValue, path, isSet2), useStrictIteration);
         maybeFreeze(rootScope, result, false);
         if (path && rootScope.patches_) {
             getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_);
@@ -4587,6 +4590,16 @@ function finalize(rootScope, value, path) {
     return state.copy_;
 }
 function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+    if (childValue == null) {
+        return;
+    }
+    if (typeof childValue !== "object" && !targetIsSet) {
+        return;
+    }
+    const childIsFrozen = isFrozen(childValue);
+    if (childIsFrozen && !targetIsSet) {
+        return;
+    }
     if (process.env.NODE_ENV !== "production" && childValue === targetObject) die(5);
     if (isDraft(childValue)) {
         const path = rootPath && parentState && parentState.type_ !== 3 /* Set */  && // Set objects are atomic since they have no keys.
@@ -4599,10 +4612,13 @@ function finalizeProperty(rootScope, parentState, targetObject, prop, childValue
     } else if (targetIsSet) {
         targetObject.add(childValue);
     }
-    if (isDraftable(childValue) && !isFrozen(childValue)) {
+    if (isDraftable(childValue) && !childIsFrozen) {
         if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
             return;
         }
+        if (parentState && parentState.base_ && parentState.base_[prop] === childValue && childIsFrozen) {
+            return;
+        }
         finalize(rootScope, childValue);
         if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop))) maybeFreeze(rootScope, childValue);
     }
@@ -4816,6 +4832,17 @@ var Immer2 = class {
    */ setUseStrictShallowCopy(value) {
         this.useStrictShallowCopy_ = value;
     }
+    /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */ setUseStrictIteration(value) {
+        this.useStrictIteration_ = value;
+    }
+    shouldUseStrictIteration() {
+        return this.useStrictIteration_;
+    }
     applyPatches(base, patches) {
         let i;
         for(i = patches.length - 1; i >= 0; i--){
@@ -4837,6 +4864,7 @@ var Immer2 = class {
     constructor(config){
         this.autoFreeze_ = true;
         this.useStrictShallowCopy_ = false;
+        this.useStrictIteration_ = true;
         /**
      * The `produce` function takes a value and a "recipe function" (whose
      * return value often depends on the base state). The recipe function is
@@ -4911,6 +4939,7 @@ var Immer2 = class {
         };
         if (typeof config?.autoFreeze === "boolean") this.setAutoFreeze(config.autoFreeze);
         if (typeof config?.useStrictShallowCopy === "boolean") this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+        if (typeof config?.useStrictIteration === "boolean") this.setUseStrictIteration(config.useStrictIteration);
     }
 };
 function createProxy(value, parent) {
@@ -4928,16 +4957,18 @@ function currentImpl(value) {
     if (!isDraftable(value) || isFrozen(value)) return value;
     const state = value[DRAFT_STATE];
     let copy;
+    let strict = true;
     if (state) {
         if (!state.modified_) return state.base_;
         state.finalized_ = true;
         copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+        strict = state.scope_.immer_.shouldUseStrictIteration();
     } else {
         copy = shallowCopy(value, true);
     }
     each(copy, (key, childValue)=>{
         set(copy, key, currentImpl(childValue));
-    });
+    }, strict);
     if (state) {
         state.finalized_ = false;
     }