Comparing version 5.0.0-alpha.5 to 5.0.0-alpha.6
35
index.js
'use strict'; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default")); | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var src_exports = {}; | ||
module.exports = __toCommonJS(src_exports); | ||
__reExport(src_exports, require("./vanilla.ts"), module.exports); | ||
__reExport(src_exports, require("./react.ts"), module.exports); | ||
var vanilla = require('zustand/vanilla'); | ||
var react = require('zustand/react'); | ||
Object.keys(vanilla).forEach(function (k) { | ||
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { | ||
enumerable: true, | ||
get: function () { return vanilla[k]; } | ||
}); | ||
}); | ||
Object.keys(react).forEach(function (k) { | ||
if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, { | ||
enumerable: true, | ||
get: function () { return react[k]; } | ||
}); | ||
}); |
'use strict'; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
const reduxImpl = (reducer, initial) => (set, _get, api) => { | ||
api.dispatch = (action) => { | ||
set((state) => reducer(state, action), false, action); | ||
return action; | ||
}; | ||
api.dispatchFromDevtools = true; | ||
return { dispatch: (...a) => api.dispatch(...a), ...initial }; | ||
}; | ||
const redux = reduxImpl; | ||
const trackedConnections = /* @__PURE__ */ new Map(); | ||
const getTrackedConnectionState = (name) => { | ||
const api = trackedConnections.get(name); | ||
if (!api) | ||
return {}; | ||
return Object.fromEntries( | ||
Object.entries(api.stores).map(([key, api2]) => [key, api2.getState()]) | ||
); | ||
}; | ||
const extractConnectionInformation = (store, extensionConnector, options) => { | ||
if (store === void 0) { | ||
return { | ||
type: "untracked", | ||
connection: extensionConnector.connect(options) | ||
}; | ||
} | ||
return to; | ||
const existingConnection = trackedConnections.get(options.name); | ||
if (existingConnection) { | ||
return { type: "tracked", store, ...existingConnection }; | ||
} | ||
const newConnection = { | ||
connection: extensionConnector.connect(options), | ||
stores: {} | ||
}; | ||
trackedConnections.set(options.name, newConnection); | ||
return { type: "tracked", store, ...newConnection }; | ||
}; | ||
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default")); | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var middleware_exports = {}; | ||
module.exports = __toCommonJS(middleware_exports); | ||
__reExport(middleware_exports, require("./middleware/redux.ts"), module.exports); | ||
__reExport(middleware_exports, require("./middleware/devtools.ts"), module.exports); | ||
__reExport(middleware_exports, require("./middleware/subscribeWithSelector.ts"), module.exports); | ||
__reExport(middleware_exports, require("./middleware/combine.ts"), module.exports); | ||
__reExport(middleware_exports, require("./middleware/persist.ts"), module.exports); | ||
const devtoolsImpl = (fn, devtoolsOptions = {}) => (set, get, api) => { | ||
const { enabled, anonymousActionType, store, ...options } = devtoolsOptions; | ||
let extensionConnector; | ||
try { | ||
extensionConnector = (enabled != null ? enabled : process.env.NODE_ENV !== "production") && window.__REDUX_DEVTOOLS_EXTENSION__; | ||
} catch (e) { | ||
} | ||
if (!extensionConnector) { | ||
if (process.env.NODE_ENV !== "production" && enabled) { | ||
console.warn( | ||
"[zustand devtools middleware] Please install/enable Redux devtools extension" | ||
); | ||
} | ||
return fn(set, get, api); | ||
} | ||
const { connection, ...connectionInformation } = extractConnectionInformation(store, extensionConnector, options); | ||
let isRecording = true; | ||
api.setState = (state, replace, nameOrAction) => { | ||
const r = set(state, replace); | ||
if (!isRecording) | ||
return r; | ||
const action = nameOrAction === void 0 ? { type: anonymousActionType || "anonymous" } : typeof nameOrAction === "string" ? { type: nameOrAction } : nameOrAction; | ||
if (store === void 0) { | ||
connection == null ? void 0 : connection.send(action, get()); | ||
return r; | ||
} | ||
connection == null ? void 0 : connection.send( | ||
{ | ||
...action, | ||
type: `${store}/${action.type}` | ||
}, | ||
{ | ||
...getTrackedConnectionState(options.name), | ||
[store]: api.getState() | ||
} | ||
); | ||
return r; | ||
}; | ||
const setStateFromDevtools = (...a) => { | ||
const originalIsRecording = isRecording; | ||
isRecording = false; | ||
set(...a); | ||
isRecording = originalIsRecording; | ||
}; | ||
const initialState = fn(api.setState, get, api); | ||
if (connectionInformation.type === "untracked") { | ||
connection == null ? void 0 : connection.init(initialState); | ||
} else { | ||
connectionInformation.stores[connectionInformation.store] = api; | ||
connection == null ? void 0 : connection.init( | ||
Object.fromEntries( | ||
Object.entries(connectionInformation.stores).map(([key, store2]) => [ | ||
key, | ||
key === connectionInformation.store ? initialState : store2.getState() | ||
]) | ||
) | ||
); | ||
} | ||
if (api.dispatchFromDevtools && typeof api.dispatch === "function") { | ||
let didWarnAboutReservedActionType = false; | ||
const originalDispatch = api.dispatch; | ||
api.dispatch = (...a) => { | ||
if (process.env.NODE_ENV !== "production" && a[0].type === "__setState" && !didWarnAboutReservedActionType) { | ||
console.warn( | ||
'[zustand devtools middleware] "__setState" action type is reserved to set state from the devtools. Avoid using it.' | ||
); | ||
didWarnAboutReservedActionType = true; | ||
} | ||
originalDispatch(...a); | ||
}; | ||
} | ||
connection.subscribe((message) => { | ||
var _a; | ||
switch (message.type) { | ||
case "ACTION": | ||
if (typeof message.payload !== "string") { | ||
console.error( | ||
"[zustand devtools middleware] Unsupported action format" | ||
); | ||
return; | ||
} | ||
return parseJsonThen( | ||
message.payload, | ||
(action) => { | ||
if (action.type === "__setState") { | ||
if (store === void 0) { | ||
setStateFromDevtools(action.state); | ||
return; | ||
} | ||
if (Object.keys(action.state).length !== 1) { | ||
console.error( | ||
` | ||
[zustand devtools middleware] Unsupported __setState action format. | ||
When using 'store' option in devtools(), the 'state' should have only one key, which is a value of 'store' that was passed in devtools(), | ||
and value of this only key should be a state object. Example: { "type": "__setState", "state": { "abc123Store": { "foo": "bar" } } } | ||
` | ||
); | ||
} | ||
const stateFromDevtools = action.state[store]; | ||
if (stateFromDevtools === void 0 || stateFromDevtools === null) { | ||
return; | ||
} | ||
if (JSON.stringify(api.getState()) !== JSON.stringify(stateFromDevtools)) { | ||
setStateFromDevtools(stateFromDevtools); | ||
} | ||
return; | ||
} | ||
if (!api.dispatchFromDevtools) | ||
return; | ||
if (typeof api.dispatch !== "function") | ||
return; | ||
api.dispatch(action); | ||
} | ||
); | ||
case "DISPATCH": | ||
switch (message.payload.type) { | ||
case "RESET": | ||
setStateFromDevtools(initialState); | ||
if (store === void 0) { | ||
return connection == null ? void 0 : connection.init(api.getState()); | ||
} | ||
return connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name)); | ||
case "COMMIT": | ||
if (store === void 0) { | ||
connection == null ? void 0 : connection.init(api.getState()); | ||
return; | ||
} | ||
return connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name)); | ||
case "ROLLBACK": | ||
return parseJsonThen(message.state, (state) => { | ||
if (store === void 0) { | ||
setStateFromDevtools(state); | ||
connection == null ? void 0 : connection.init(api.getState()); | ||
return; | ||
} | ||
setStateFromDevtools(state[store]); | ||
connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name)); | ||
}); | ||
case "JUMP_TO_STATE": | ||
case "JUMP_TO_ACTION": | ||
return parseJsonThen(message.state, (state) => { | ||
if (store === void 0) { | ||
setStateFromDevtools(state); | ||
return; | ||
} | ||
if (JSON.stringify(api.getState()) !== JSON.stringify(state[store])) { | ||
setStateFromDevtools(state[store]); | ||
} | ||
}); | ||
case "IMPORT_STATE": { | ||
const { nextLiftedState } = message.payload; | ||
const lastComputedState = (_a = nextLiftedState.computedStates.slice(-1)[0]) == null ? void 0 : _a.state; | ||
if (!lastComputedState) | ||
return; | ||
if (store === void 0) { | ||
setStateFromDevtools(lastComputedState); | ||
} else { | ||
setStateFromDevtools(lastComputedState[store]); | ||
} | ||
connection == null ? void 0 : connection.send( | ||
null, | ||
// FIXME no-any | ||
nextLiftedState | ||
); | ||
return; | ||
} | ||
case "PAUSE_RECORDING": | ||
return isRecording = !isRecording; | ||
} | ||
return; | ||
} | ||
}); | ||
return initialState; | ||
}; | ||
const devtools = devtoolsImpl; | ||
const parseJsonThen = (stringified, f) => { | ||
let parsed; | ||
try { | ||
parsed = JSON.parse(stringified); | ||
} catch (e) { | ||
console.error( | ||
"[zustand devtools middleware] Could not parse the received json", | ||
e | ||
); | ||
} | ||
if (parsed !== void 0) | ||
f(parsed); | ||
}; | ||
const subscribeWithSelectorImpl = (fn) => (set, get, api) => { | ||
const origSubscribe = api.subscribe; | ||
api.subscribe = (selector, optListener, options) => { | ||
let listener = selector; | ||
if (optListener) { | ||
const equalityFn = (options == null ? void 0 : options.equalityFn) || Object.is; | ||
let currentSlice = selector(api.getState()); | ||
listener = (state) => { | ||
const nextSlice = selector(state); | ||
if (!equalityFn(currentSlice, nextSlice)) { | ||
const previousSlice = currentSlice; | ||
optListener(currentSlice = nextSlice, previousSlice); | ||
} | ||
}; | ||
if (options == null ? void 0 : options.fireImmediately) { | ||
optListener(currentSlice, currentSlice); | ||
} | ||
} | ||
return origSubscribe(listener); | ||
}; | ||
const initialState = fn(set, get, api); | ||
return initialState; | ||
}; | ||
const subscribeWithSelector = subscribeWithSelectorImpl; | ||
const combine = (initialState, create) => (...a) => Object.assign({}, initialState, create(...a)); | ||
function createJSONStorage(getStorage, options) { | ||
let storage; | ||
try { | ||
storage = getStorage(); | ||
} catch (e) { | ||
return; | ||
} | ||
const persistStorage = { | ||
getItem: (name) => { | ||
var _a; | ||
const parse = (str2) => { | ||
if (str2 === null) { | ||
return null; | ||
} | ||
return JSON.parse(str2, options == null ? void 0 : options.reviver); | ||
}; | ||
const str = (_a = storage.getItem(name)) != null ? _a : null; | ||
if (str instanceof Promise) { | ||
return str.then(parse); | ||
} | ||
return parse(str); | ||
}, | ||
setItem: (name, newValue) => storage.setItem( | ||
name, | ||
JSON.stringify(newValue, options == null ? void 0 : options.replacer) | ||
), | ||
removeItem: (name) => storage.removeItem(name) | ||
}; | ||
return persistStorage; | ||
} | ||
const toThenable = (fn) => (input) => { | ||
try { | ||
const result = fn(input); | ||
if (result instanceof Promise) { | ||
return result; | ||
} | ||
return { | ||
then(onFulfilled) { | ||
return toThenable(onFulfilled)(result); | ||
}, | ||
catch(_onRejected) { | ||
return this; | ||
} | ||
}; | ||
} catch (e) { | ||
return { | ||
then(_onFulfilled) { | ||
return this; | ||
}, | ||
catch(onRejected) { | ||
return toThenable(onRejected)(e); | ||
} | ||
}; | ||
} | ||
}; | ||
const persistImpl = (config, baseOptions) => (set, get, api) => { | ||
let options = { | ||
storage: createJSONStorage(() => localStorage), | ||
partialize: (state) => state, | ||
version: 0, | ||
merge: (persistedState, currentState) => ({ | ||
...currentState, | ||
...persistedState | ||
}), | ||
...baseOptions | ||
}; | ||
let hasHydrated = false; | ||
const hydrationListeners = /* @__PURE__ */ new Set(); | ||
const finishHydrationListeners = /* @__PURE__ */ new Set(); | ||
let storage = options.storage; | ||
if (!storage) { | ||
return config( | ||
(...args) => { | ||
console.warn( | ||
`[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.` | ||
); | ||
set(...args); | ||
}, | ||
get, | ||
api | ||
); | ||
} | ||
const setItem = () => { | ||
const state = options.partialize({ ...get() }); | ||
return storage.setItem(options.name, { | ||
state, | ||
version: options.version | ||
}); | ||
}; | ||
const savedSetState = api.setState; | ||
api.setState = (state, replace) => { | ||
savedSetState(state, replace); | ||
void setItem(); | ||
}; | ||
const configResult = config( | ||
(...args) => { | ||
set(...args); | ||
void setItem(); | ||
}, | ||
get, | ||
api | ||
); | ||
api.getInitialState = () => configResult; | ||
let stateFromStorage; | ||
const hydrate = () => { | ||
var _a, _b; | ||
if (!storage) | ||
return; | ||
hasHydrated = false; | ||
hydrationListeners.forEach((cb) => { | ||
var _a2; | ||
return cb((_a2 = get()) != null ? _a2 : configResult); | ||
}); | ||
const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0; | ||
return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => { | ||
if (deserializedStorageValue) { | ||
if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) { | ||
if (options.migrate) { | ||
return options.migrate( | ||
deserializedStorageValue.state, | ||
deserializedStorageValue.version | ||
); | ||
} | ||
console.error( | ||
`State loaded from storage couldn't be migrated since no migrate function was provided` | ||
); | ||
} else { | ||
return deserializedStorageValue.state; | ||
} | ||
} | ||
}).then((migratedState) => { | ||
var _a2; | ||
stateFromStorage = options.merge( | ||
migratedState, | ||
(_a2 = get()) != null ? _a2 : configResult | ||
); | ||
set(stateFromStorage, true); | ||
return setItem(); | ||
}).then(() => { | ||
postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0); | ||
stateFromStorage = get(); | ||
hasHydrated = true; | ||
finishHydrationListeners.forEach((cb) => cb(stateFromStorage)); | ||
}).catch((e) => { | ||
postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e); | ||
}); | ||
}; | ||
api.persist = { | ||
setOptions: (newOptions) => { | ||
options = { | ||
...options, | ||
...newOptions | ||
}; | ||
if (newOptions.storage) { | ||
storage = newOptions.storage; | ||
} | ||
}, | ||
clearStorage: () => { | ||
storage == null ? void 0 : storage.removeItem(options.name); | ||
}, | ||
getOptions: () => options, | ||
rehydrate: () => hydrate(), | ||
hasHydrated: () => hasHydrated, | ||
onHydrate: (cb) => { | ||
hydrationListeners.add(cb); | ||
return () => { | ||
hydrationListeners.delete(cb); | ||
}; | ||
}, | ||
onFinishHydration: (cb) => { | ||
finishHydrationListeners.add(cb); | ||
return () => { | ||
finishHydrationListeners.delete(cb); | ||
}; | ||
} | ||
}; | ||
if (!options.skipHydration) { | ||
hydrate(); | ||
} | ||
return stateFromStorage || configResult; | ||
}; | ||
const persist = persistImpl; | ||
exports.combine = combine; | ||
exports.createJSONStorage = createJSONStorage; | ||
exports.devtools = devtools; | ||
exports.persist = persist; | ||
exports.redux = redux; | ||
exports.subscribeWithSelector = subscribeWithSelector; |
'use strict'; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var immer_exports = {}; | ||
__export(immer_exports, { | ||
immer: () => immer | ||
}); | ||
module.exports = __toCommonJS(immer_exports); | ||
var import_immer = require("immer"); | ||
var immer$1 = require('immer'); | ||
const immerImpl = (initializer) => (set, get, store) => { | ||
store.setState = (updater, replace, ...a) => { | ||
const nextState = typeof updater === "function" ? (0, import_immer.produce)(updater) : updater; | ||
const nextState = typeof updater === "function" ? immer$1.produce(updater) : updater; | ||
return set(nextState, replace, ...a); | ||
@@ -34,1 +13,3 @@ }; | ||
const immer = immerImpl; | ||
exports.immer = immer; |
{ | ||
"name": "zustand", | ||
"private": false, | ||
"version": "5.0.0-alpha.5", | ||
"version": "5.0.0-alpha.6", | ||
"publishConfig": { | ||
@@ -6,0 +6,0 @@ "tag": "next" |
45
react.js
'use strict'; | ||
var __create = Object.create; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __getProtoOf = Object.getPrototypeOf; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( | ||
// If the importer is in node compatibility mode or this is not an ESM | ||
// file that has been converted to a CommonJS file using a Babel- | ||
// compatible transform (i.e. "__esModule" has not been set), then set | ||
// "default" to the CommonJS "module.exports" for node compatibility. | ||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, | ||
mod | ||
)); | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var react_exports = {}; | ||
__export(react_exports, { | ||
create: () => create, | ||
useStore: () => useStore | ||
}); | ||
module.exports = __toCommonJS(react_exports); | ||
var import_react = __toESM(require("react")); | ||
var import_vanilla = require("./vanilla.ts"); | ||
const { useDebugValue, useSyncExternalStore } = import_react.default; | ||
var ReactExports = require('react'); | ||
var vanilla = require('zustand/vanilla'); | ||
const { useDebugValue, useSyncExternalStore } = ReactExports; | ||
const identity = (arg) => arg; | ||
@@ -50,3 +18,3 @@ function useStore(api, selector = identity) { | ||
const createImpl = (createState) => { | ||
const api = (0, import_vanilla.createStore)(createState); | ||
const api = vanilla.createStore(createState); | ||
const useBoundStore = (selector) => useStore(api, selector); | ||
@@ -57,1 +25,4 @@ Object.assign(useBoundStore, api); | ||
const create = (createState) => createState ? createImpl(createState) : createImpl; | ||
exports.create = create; | ||
exports.useStore = useStore; |
'use strict'; | ||
var __create = Object.create; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __getProtoOf = Object.getPrototypeOf; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( | ||
// If the importer is in node compatibility mode or this is not an ESM | ||
// file that has been converted to a CommonJS file using a Babel- | ||
// compatible transform (i.e. "__esModule" has not been set), then set | ||
// "default" to the CommonJS "module.exports" for node compatibility. | ||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, | ||
mod | ||
)); | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var shallow_exports = {}; | ||
__export(shallow_exports, { | ||
useShallow: () => useShallow | ||
}); | ||
module.exports = __toCommonJS(shallow_exports); | ||
var import_react = __toESM(require("react")); | ||
var import_shallow = require("../vanilla/shallow.ts"); | ||
const { useRef } = import_react.default; | ||
var ReactExports = require('react'); | ||
var shallow = require('zustand/vanilla/shallow'); | ||
const { useRef } = ReactExports; | ||
function useShallow(selector) { | ||
@@ -42,4 +11,6 @@ const prev = useRef(); | ||
const next = selector(state); | ||
return (0, import_shallow.shallow)(prev.current, next) ? prev.current : prev.current = next; | ||
return shallow.shallow(prev.current, next) ? prev.current : prev.current = next; | ||
}; | ||
} | ||
exports.useShallow = useShallow; |
'use strict'; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var shallow_exports = {}; | ||
__export(shallow_exports, { | ||
shallow: () => import_shallow.shallow, | ||
useShallow: () => import_shallow2.useShallow | ||
var shallow = require('zustand/vanilla/shallow'); | ||
var shallow$1 = require('zustand/react/shallow'); | ||
Object.defineProperty(exports, "shallow", { | ||
enumerable: true, | ||
get: function () { return shallow.shallow; } | ||
}); | ||
module.exports = __toCommonJS(shallow_exports); | ||
var import_shallow = require("./vanilla/shallow.ts"); | ||
var import_shallow2 = require("./react/shallow.ts"); | ||
Object.defineProperty(exports, "useShallow", { | ||
enumerable: true, | ||
get: function () { return shallow$1.useShallow; } | ||
}); |
'use strict'; | ||
var __create = Object.create; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __getProtoOf = Object.getPrototypeOf; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( | ||
// If the importer is in node compatibility mode or this is not an ESM | ||
// file that has been converted to a CommonJS file using a Babel- | ||
// compatible transform (i.e. "__esModule" has not been set), then set | ||
// "default" to the CommonJS "module.exports" for node compatibility. | ||
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, | ||
mod | ||
)); | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var traditional_exports = {}; | ||
__export(traditional_exports, { | ||
createWithEqualityFn: () => createWithEqualityFn, | ||
useStoreWithEqualityFn: () => useStoreWithEqualityFn | ||
}); | ||
module.exports = __toCommonJS(traditional_exports); | ||
var import_react = __toESM(require("react")); | ||
var import_with_selector = __toESM(require("use-sync-external-store/shim/with-selector")); | ||
var import_vanilla = require("./vanilla.ts"); | ||
const { useDebugValue } = import_react.default; | ||
const { useSyncExternalStoreWithSelector } = import_with_selector.default; | ||
var ReactExports = require('react'); | ||
var useSyncExternalStoreExports = require('use-sync-external-store/shim/with-selector'); | ||
var vanilla = require('zustand/vanilla'); | ||
const { useDebugValue } = ReactExports; | ||
const { useSyncExternalStoreWithSelector } = useSyncExternalStoreExports; | ||
const identity = (arg) => arg; | ||
@@ -54,3 +22,3 @@ function useStoreWithEqualityFn(api, selector = identity, equalityFn) { | ||
const createWithEqualityFnImpl = (createState, defaultEqualityFn) => { | ||
const api = (0, import_vanilla.createStore)(createState); | ||
const api = vanilla.createStore(createState); | ||
const useBoundStoreWithEqualityFn = (selector, equalityFn = defaultEqualityFn) => useStoreWithEqualityFn(api, selector, equalityFn); | ||
@@ -61,1 +29,4 @@ Object.assign(useBoundStoreWithEqualityFn, api); | ||
const createWithEqualityFn = (createState, defaultEqualityFn) => createState ? createWithEqualityFnImpl(createState, defaultEqualityFn) : createWithEqualityFnImpl; | ||
exports.createWithEqualityFn = createWithEqualityFn; | ||
exports.useStoreWithEqualityFn = useStoreWithEqualityFn; |
'use strict'; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var vanilla_exports = {}; | ||
__export(vanilla_exports, { | ||
createStore: () => createStore | ||
}); | ||
module.exports = __toCommonJS(vanilla_exports); | ||
const createStoreImpl = (createState) => { | ||
@@ -47,1 +25,3 @@ let state; | ||
const createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl; | ||
exports.createStore = createStore; |
'use strict'; | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
const isIterable = (obj) => Symbol.iterator in obj; | ||
const compareMapLike = (iterableA, iterableB) => { | ||
const mapA = iterableA instanceof Map ? iterableA : new Map(iterableA); | ||
const mapB = iterableB instanceof Map ? iterableB : new Map(iterableB); | ||
if (mapA.size !== mapB.size) | ||
return false; | ||
for (const [key, value] of mapA) { | ||
if (!Object.is(value, mapB.get(key))) { | ||
return false; | ||
} | ||
} | ||
return to; | ||
return true; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
var shallow_exports = {}; | ||
__export(shallow_exports, { | ||
shallow: () => shallow | ||
}); | ||
module.exports = __toCommonJS(shallow_exports); | ||
function shallow(objA, objB) { | ||
@@ -32,21 +23,21 @@ if (Object.is(objA, objB)) { | ||
} | ||
if (objA instanceof Map && objB instanceof Map) { | ||
if (objA.size !== objB.size) | ||
return false; | ||
for (const [key, value] of objA) { | ||
if (!Object.is(value, objB.get(key))) { | ||
return false; | ||
} | ||
if (isIterable(objA) && isIterable(objB)) { | ||
const iteratorA = objA[Symbol.iterator](); | ||
const iteratorB = objB[Symbol.iterator](); | ||
let nextA = iteratorA.next(); | ||
let nextB = iteratorB.next(); | ||
if (Array.isArray(nextA.value) && Array.isArray(nextB.value) && nextA.value.length === 2 && nextB.value.length === 2) { | ||
return compareMapLike( | ||
objA, | ||
objB | ||
); | ||
} | ||
return true; | ||
} | ||
if (objA instanceof Set && objB instanceof Set) { | ||
if (objA.size !== objB.size) | ||
return false; | ||
for (const value of objA) { | ||
if (!objB.has(value)) { | ||
while (!nextA.done && !nextB.done) { | ||
if (!Object.is(nextA.value, nextB.value)) { | ||
return false; | ||
} | ||
nextA = iteratorA.next(); | ||
nextB = iteratorB.next(); | ||
} | ||
return true; | ||
return !!nextA.done && !!nextB.done; | ||
} | ||
@@ -64,1 +55,3 @@ const keysA = Object.keys(objA); | ||
} | ||
exports.shallow = shallow; |
Sorry, the diff of this file is not supported yet
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
87718
1483