297 lines
7.8 KiB
JavaScript
297 lines
7.8 KiB
JavaScript
import { w as withGet } from './index3-4H3SMWet.js';
|
|
import { w as writable } from './index2-D4yenS_5.js';
|
|
import { g as get_store_value, k as createEventDispatcher } from './lifecycle-px-3doLe.js';
|
|
|
|
const overridable = (_store, onChange) => {
|
|
const store = withGet(_store);
|
|
const update = (updater, sideEffect) => {
|
|
store.update((curr) => {
|
|
const next = updater(curr);
|
|
let res = next;
|
|
if (onChange) {
|
|
res = onChange({ curr, next });
|
|
}
|
|
sideEffect?.(res);
|
|
return res;
|
|
});
|
|
};
|
|
const set = (curr) => {
|
|
update(() => curr);
|
|
};
|
|
return {
|
|
...store,
|
|
update,
|
|
set
|
|
};
|
|
};
|
|
function toWritableStores(properties) {
|
|
const result = {};
|
|
Object.keys(properties).forEach((key) => {
|
|
const propertyKey = key;
|
|
const value = properties[propertyKey];
|
|
result[propertyKey] = withGet(writable(value));
|
|
});
|
|
return result;
|
|
}
|
|
function createBitAttrs(bit, parts) {
|
|
const attrs = {};
|
|
parts.forEach((part) => {
|
|
attrs[part] = {
|
|
[`data-${bit}-${part}`]: ""
|
|
};
|
|
});
|
|
return (part) => attrs[part];
|
|
}
|
|
function disabledAttrs(disabled) {
|
|
return disabled ? { "aria-disabled": "true", "data-disabled": "" } : { "aria-disabled": void 0, "data-disabled": void 0 };
|
|
}
|
|
function createDispatcher() {
|
|
const dispatch = createEventDispatcher();
|
|
return (e) => {
|
|
const { originalEvent } = e.detail;
|
|
const { cancelable } = e;
|
|
const type = originalEvent.type;
|
|
const shouldContinue = dispatch(type, { originalEvent, currentTarget: originalEvent.currentTarget }, { cancelable });
|
|
if (!shouldContinue) {
|
|
e.preventDefault();
|
|
}
|
|
};
|
|
}
|
|
function removeUndefined(obj) {
|
|
const result = {};
|
|
for (const key in obj) {
|
|
const value = obj[key];
|
|
if (value !== void 0) {
|
|
result[key] = value;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getOptionUpdater(options) {
|
|
return function(key, value) {
|
|
if (value === void 0)
|
|
return;
|
|
const store = options[key];
|
|
if (store) {
|
|
store.set(value);
|
|
}
|
|
};
|
|
}
|
|
function cn(...classes) {
|
|
return classes.filter(Boolean).join(" ");
|
|
}
|
|
const isBrowser = typeof document !== "undefined";
|
|
function clientWritable(initialValue) {
|
|
const store = writable(initialValue);
|
|
function set(value) {
|
|
if (isBrowser) {
|
|
store.set(value);
|
|
}
|
|
}
|
|
function update(updater) {
|
|
if (isBrowser) {
|
|
store.update(updater);
|
|
}
|
|
}
|
|
return {
|
|
subscribe: store.subscribe,
|
|
set,
|
|
update
|
|
};
|
|
}
|
|
let toastsCounter = 0;
|
|
function createToastState() {
|
|
const toasts = clientWritable([]);
|
|
const heights = clientWritable([]);
|
|
function addToast(data) {
|
|
toasts.update((prev) => [data, ...prev]);
|
|
}
|
|
function create(data) {
|
|
const { message: message2, ...rest } = data;
|
|
const id = typeof data?.id === "number" || data.id && data.id?.length > 0 ? data.id : toastsCounter++;
|
|
const dismissable = data.dismissable === void 0 ? true : data.dismissable;
|
|
const type = data.type === void 0 ? "default" : data.type;
|
|
const $toasts = get_store_value(toasts);
|
|
const alreadyExists = $toasts.find((toast2) => {
|
|
return toast2.id === id;
|
|
});
|
|
if (alreadyExists) {
|
|
toasts.update((prev) => prev.map((toast2) => {
|
|
if (toast2.id === id) {
|
|
return {
|
|
...toast2,
|
|
...data,
|
|
id,
|
|
title: message2,
|
|
dismissable,
|
|
type,
|
|
updated: true
|
|
};
|
|
}
|
|
return {
|
|
...toast2,
|
|
updated: false
|
|
};
|
|
}));
|
|
} else {
|
|
addToast({ ...rest, id, title: message2, dismissable, type });
|
|
}
|
|
return id;
|
|
}
|
|
function dismiss(id) {
|
|
if (id === void 0) {
|
|
toasts.set([]);
|
|
return;
|
|
}
|
|
toasts.update((prev) => prev.filter((toast2) => toast2.id !== id));
|
|
return id;
|
|
}
|
|
function message(message2, data) {
|
|
return create({ ...data, type: "default", message: message2 });
|
|
}
|
|
function error(message2, data) {
|
|
return create({ ...data, type: "error", message: message2 });
|
|
}
|
|
function success(message2, data) {
|
|
return create({ ...data, type: "success", message: message2 });
|
|
}
|
|
function info(message2, data) {
|
|
return create({ ...data, type: "info", message: message2 });
|
|
}
|
|
function warning(message2, data) {
|
|
return create({ ...data, type: "warning", message: message2 });
|
|
}
|
|
function loading(message2, data) {
|
|
return create({ ...data, type: "loading", message: message2 });
|
|
}
|
|
function promise(promise2, data) {
|
|
if (!data) {
|
|
return;
|
|
}
|
|
let id = void 0;
|
|
if (data.loading !== void 0) {
|
|
id = create({
|
|
...data,
|
|
promise: promise2,
|
|
type: "loading",
|
|
message: data.loading
|
|
});
|
|
}
|
|
const p = promise2 instanceof Promise ? promise2 : promise2();
|
|
let shouldDismiss = id !== void 0;
|
|
p.then((response) => {
|
|
if (response && typeof response.ok === "boolean" && !response.ok) {
|
|
shouldDismiss = false;
|
|
const message2 = typeof data.error === "function" ? (
|
|
// @ts-expect-error: Incorrect response type
|
|
data.error(`HTTP error! status: ${response.status}`)
|
|
) : data.error;
|
|
create({ id, type: "error", message: message2 });
|
|
} else if (data.success !== void 0) {
|
|
shouldDismiss = false;
|
|
const message2 = (
|
|
// @ts-expect-error: TODO: Better function checking
|
|
typeof data.success === "function" ? data.success(response) : data.success
|
|
);
|
|
create({ id, type: "success", message: message2 });
|
|
}
|
|
}).catch((error2) => {
|
|
if (data.error !== void 0) {
|
|
shouldDismiss = false;
|
|
const message2 = (
|
|
// @ts-expect-error: TODO: Better function checking
|
|
typeof data.error === "function" ? data.error(error2) : data.error
|
|
);
|
|
create({ id, type: "error", message: message2 });
|
|
}
|
|
}).finally(() => {
|
|
if (shouldDismiss) {
|
|
dismiss(id);
|
|
id = void 0;
|
|
}
|
|
data.finally?.();
|
|
});
|
|
return id;
|
|
}
|
|
function custom(component, data) {
|
|
const id = data?.id || toastsCounter++;
|
|
create({ component, id, ...data });
|
|
return id;
|
|
}
|
|
function removeHeight(id) {
|
|
heights.update((prev) => prev.filter((height) => height.toastId !== id));
|
|
}
|
|
function setHeight(data) {
|
|
const exists = get_store_value(heights).find((el) => el.toastId === data.toastId);
|
|
if (exists === void 0) {
|
|
heights.update((prev) => [data, ...prev]);
|
|
return;
|
|
}
|
|
heights.update((prev) => prev.map((el) => {
|
|
if (el.toastId === data.toastId) {
|
|
return data;
|
|
} else {
|
|
return el;
|
|
}
|
|
}));
|
|
}
|
|
function reset() {
|
|
toasts.set([]);
|
|
heights.set([]);
|
|
}
|
|
return {
|
|
// methods
|
|
create,
|
|
addToast,
|
|
dismiss,
|
|
message,
|
|
error,
|
|
success,
|
|
info,
|
|
warning,
|
|
loading,
|
|
promise,
|
|
custom,
|
|
removeHeight,
|
|
setHeight,
|
|
reset,
|
|
// stores
|
|
toasts,
|
|
heights
|
|
};
|
|
}
|
|
const toastState = createToastState();
|
|
function toastFunction(message, data) {
|
|
return toastState.create({
|
|
message,
|
|
...data
|
|
});
|
|
}
|
|
const basicToast = toastFunction;
|
|
const toast = Object.assign(basicToast, {
|
|
success: toastState.success,
|
|
info: toastState.info,
|
|
warning: toastState.warning,
|
|
error: toastState.error,
|
|
custom: toastState.custom,
|
|
message: toastState.message,
|
|
promise: toastState.promise,
|
|
dismiss: toastState.dismiss,
|
|
loading: toastState.loading
|
|
});
|
|
const useEffect = (subscribe) => ({ subscribe });
|
|
|
|
let urlAlphabet =
|
|
'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
|
|
let nanoid = (size = 21) => {
|
|
let id = '';
|
|
let i = size;
|
|
while (i--) {
|
|
id += urlAlphabet[(Math.random() * 64) | 0];
|
|
}
|
|
return id
|
|
};
|
|
|
|
export { createBitAttrs as a, cn as b, createDispatcher as c, disabledAttrs as d, toWritableStores as e, toast as f, getOptionUpdater as g, nanoid as n, overridable as o, removeUndefined as r, toastState as t, useEffect as u };
|
|
//# sourceMappingURL=index-pRP-dlMc.js.map
|