@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/notification/Notification.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,308 @@
+import { isRenderable, preventDefault } from "../_util/index.js";
+import { useTouch } from "../_util/hooks/useTouch.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useLocale } from "../locale/index.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, renderSlot, resolveDynamicComponent, unref, useSlots, watch, withModifiers } from "vue";
+import { CheckCircleFilled, CloseCircleFilled, CloseOutlined, ExclamationCircleFilled, InfoCircleFilled } from "@antdv-next/icons";
+// src/notification/Notification.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["role"];
+var _hoisted_2 = ["aria-label", "disabled"];
+var SWIPE_X = 80;
+var SWIPE_Y = 32;
+/** a flick faster than this (px / ms) dismisses it as well */
+var VELOCITY = .5;
+var FLICK_DISTANCE = 16;
+var Notification_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmNotification",
+	inheritAttrs: false,
+	__name: "Notification",
+	props: {
+		title: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		description: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		actions: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		icon: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		type: {},
+		duration: { default: 4.5 },
+		times: { default: 0 },
+		showProgress: {
+			type: Boolean,
+			default: false
+		},
+		pauseOnHover: {
+			type: Boolean,
+			default: true
+		},
+		closable: {
+			type: Boolean,
+			default: true
+		},
+		closeIcon: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		closeDisabled: {
+			type: Boolean,
+			default: false
+		},
+		placement: { default: "top" },
+		role: { default: "alert" },
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: ["close", "click"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		/** a swipe further than this (px) dismisses the card */
+		const locale = useLocale("common");
+		const icons = {
+			info: InfoCircleFilled,
+			success: CheckCircleFilled,
+			error: CloseCircleFilled,
+			warning: ExclamationCircleFilled
+		};
+		const rootRef = ref();
+		const hasIcon = computed(() => !!slots.icon || isRenderable(props.icon) || !!props.type);
+		const hasTitle = computed(() => !!slots.title || isRenderable(props.title));
+		const hasDescription = computed(() => !!slots.description || isRenderable(props.description));
+		const hasActions = computed(() => !!slots.actions || isRenderable(props.actions));
+		const showClose = computed(() => props.closable && props.closeIcon !== null && props.closeIcon !== false);
+		let timer;
+		let startedAt = 0;
+		let remaining = 0;
+		let closed = false;
+		const paused = ref(false);
+		function close() {
+			if (closed) return;
+			closed = true;
+			clearTimeout(timer);
+			timer = void 0;
+			emit("close");
+		}
+		function resume() {
+			paused.value = false;
+			if (closed || props.duration <= 0 || timer) return;
+			startedAt = Date.now();
+			timer = setTimeout(close, Math.max(remaining, 0));
+		}
+		function pause() {
+			if (!timer) return;
+			clearTimeout(timer);
+			timer = void 0;
+			remaining -= Date.now() - startedAt;
+			paused.value = true;
+		}
+		function restart() {
+			clearTimeout(timer);
+			timer = void 0;
+			remaining = props.duration * 1e3;
+			resume();
+		}
+		onMounted(restart);
+		watch(() => [props.duration, props.times], restart);
+		onBeforeUnmount(() => clearTimeout(timer));
+		function hold() {
+			if (props.pauseOnHover) pause();
+		}
+		const touch = useTouch();
+		const dragging = ref(false);
+		const leaving = ref(false);
+		const offsetX = ref(0);
+		const offsetY = ref(0);
+		let suppressClick = false;
+		function onTouchStart(event) {
+			if (leaving.value) return;
+			suppressClick = false;
+			touch.start(event);
+			dragging.value = true;
+			hold();
+		}
+		function onTouchMove(event) {
+			if (!dragging.value) return;
+			touch.move(event);
+			if (touch.isHorizontal()) {
+				offsetX.value = touch.deltaX.value;
+				offsetY.value = 0;
+			} else if (touch.isVertical()) {
+				const delta = touch.deltaY.value;
+				const toEdge = props.placement === "top" ? delta < 0 : delta > 0;
+				offsetX.value = 0;
+				offsetY.value = toEdge ? delta : delta * .2;
+			}
+			if (!touch.isTap.value) preventDefault(event);
+		}
+		function onTouchEnd() {
+			if (!dragging.value) return;
+			dragging.value = false;
+			suppressClick = !touch.isTap.value;
+			const velocity = 1 / Math.max(Date.now() - touch.startTime.value, 1);
+			const x = offsetX.value;
+			const y = offsetY.value;
+			const toEdge = props.placement === "top" ? y < 0 : y > 0;
+			const dismissX = Math.abs(x) > SWIPE_X || Math.abs(x) > FLICK_DISTANCE && Math.abs(x) * velocity > VELOCITY;
+			const dismissY = toEdge && (Math.abs(y) > SWIPE_Y || Math.abs(y) > FLICK_DISTANCE && Math.abs(y) * velocity > VELOCITY);
+			if (dismissX || dismissY) {
+				leaving.value = true;
+				const el = rootRef.value;
+				if (dismissX) offsetX.value = Math.sign(x) * ((el?.offsetWidth || 320) + 32);
+				else offsetY.value = Math.sign(y) * ((el?.offsetHeight || 80) + 32);
+				close();
+				return;
+			}
+			offsetX.value = 0;
+			offsetY.value = 0;
+			resume();
+		}
+		function onClick(event) {
+			if (suppressClick) {
+				suppressClick = false;
+				return;
+			}
+			emit("click", event);
+		}
+		const dragStyle = computed(() => {
+			if (!offsetX.value && !offsetY.value) return void 0;
+			return {
+				transform: `translate3d(${offsetX.value}px, ${offsetY.value}px, 0)`,
+				opacity: leaving.value ? 0 : void 0
+			};
+		});
+		__expose({ nativeElement: rootRef });
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: ["am-notification-notice", [
+					__props.type ? `am-notification-notice-${__props.type}` : void 0,
+					{
+						"am-notification-notice-closable": showClose.value,
+						"am-notification-notice-dragging": dragging.value,
+						"am-notification-notice-with-description": hasDescription.value
+					},
+					__props.rootClass,
+					__props.classes?.root
+				]],
+				style: [__props.styles?.root, dragStyle.value],
+				role: __props.role,
+				onTouchstartPassive: onTouchStart,
+				onTouchmove: onTouchMove,
+				onTouchend: onTouchEnd,
+				onTouchcancel: onTouchEnd,
+				onMouseenter: hold,
+				onMouseleave: resume,
+				onClick
+			}), [
+				hasIcon.value ? (openBlock(), createElementBlock("span", {
+					key: 0,
+					class: normalizeClass(["am-notification-icon", __props.classes?.icon]),
+					style: normalizeStyle(__props.styles?.icon)
+				}, [renderSlot(_ctx.$slots, "icon", {}, () => [unref(isRenderable)(__props.icon) ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: __props.icon
+				}, null, 8, ["node"])) : __props.type ? (openBlock(), createBlock(resolveDynamicComponent(icons[__props.type]), { key: 1 })) : createCommentVNode("", true)])], 6)) : createCommentVNode("", true),
+				createElementVNode("div", {
+					class: normalizeClass(["am-notification-section", __props.classes?.section]),
+					style: normalizeStyle(__props.styles?.section)
+				}, [
+					hasTitle.value ? (openBlock(), createElementBlock("div", {
+						key: 0,
+						class: normalizeClass(["am-notification-title", __props.classes?.title]),
+						style: normalizeStyle(__props.styles?.title)
+					}, [renderSlot(_ctx.$slots, "title", {}, () => [createVNode(unref(RenderNode_default), { node: __props.title }, null, 8, ["node"])])], 6)) : createCommentVNode("", true),
+					hasDescription.value ? (openBlock(), createElementBlock("div", {
+						key: 1,
+						class: normalizeClass(["am-notification-description", __props.classes?.description]),
+						style: normalizeStyle(__props.styles?.description)
+					}, [renderSlot(_ctx.$slots, "description", {}, () => [createVNode(unref(RenderNode_default), { node: __props.description }, null, 8, ["node"])])], 6)) : createCommentVNode("", true),
+					hasActions.value ? (openBlock(), createElementBlock("div", {
+						key: 2,
+						class: normalizeClass(["am-notification-actions", __props.classes?.actions]),
+						style: normalizeStyle(__props.styles?.actions)
+					}, [renderSlot(_ctx.$slots, "actions", {}, () => [createVNode(unref(RenderNode_default), { node: __props.actions }, null, 8, ["node"])])], 6)) : createCommentVNode("", true)
+				], 6),
+				showClose.value ? (openBlock(), createElementBlock("button", {
+					key: 1,
+					type: "button",
+					class: normalizeClass(["am-notification-close", __props.classes?.close]),
+					style: normalizeStyle(__props.styles?.close),
+					"aria-label": unref(locale).close,
+					disabled: __props.closeDisabled,
+					onClick: withModifiers(close, ["stop"])
+				}, [renderSlot(_ctx.$slots, "closeIcon", {}, () => [unref(isRenderable)(__props.closeIcon) && __props.closeIcon !== true ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: __props.closeIcon
+				}, null, 8, ["node"])) : (openBlock(), createBlock(unref(CloseOutlined), { key: 1 }))])], 14, _hoisted_2)) : createCommentVNode("", true),
+				__props.showProgress && __props.duration > 0 ? (openBlock(), createElementBlock("div", {
+					key: 2,
+					class: normalizeClass(["am-notification-progress", __props.classes?.progress]),
+					style: normalizeStyle(__props.styles?.progress)
+				}, [(openBlock(), createElementBlock("div", {
+					key: __props.times,
+					class: "am-notification-progress-bar",
+					style: normalizeStyle({
+						animationDuration: `${__props.duration}s`,
+						animationPlayState: paused.value ? "paused" : "running"
+					})
+				}, null, 4))], 6)) : createCommentVNode("", true)
+			], 16, _hoisted_1);
+		};
+	}
+});
+export { Notification_vue_vue_type_script_setup_true_lang_default as default };

package/dist/notification/NotificationHolder.js

@@ -0,0 +1,4 @@
+import NotificationHolder_vue_vue_type_script_setup_true_lang_default from "./NotificationHolder.vue_vue_type_script_setup_true_lang.js";
+// src/notification/NotificationHolder.vue
+var NotificationHolder_default = NotificationHolder_vue_vue_type_script_setup_true_lang_default;
+export { NotificationHolder_default as default };

package/dist/notification/NotificationHolder.vue.d.ts

@@ -0,0 +1,15 @@
+import type { NotificationHolderProps, NotificationNotice } from './interface';
+import '../style';
+import './style/index.css';
+declare const __VLS_export: import("vue").DefineComponent<NotificationHolderProps, {
+    nativeElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (key: import("../_util/type.ts").Key) => any;
+}, string, import("vue").PublicProps, Readonly<NotificationHolderProps> & Readonly<{
+    onClose?: ((key: import("../_util/type.ts").Key) => any) | undefined;
+}>, {
+    notices: NotificationNotice[];
+    stack: boolean | import("./interface").NotificationStackConfig;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/notification/NotificationHolder.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,168 @@
+import Portal_default from "../_base/Portal.js";
+import { addUnit } from "../_util/index.js";
+import { useClickAway } from "../_util/hooks/useClickAway.js";
+import Notification_default from "./Notification.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, TransitionGroup, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, onMounted, openBlock, reactive, ref, renderList, unref, watch, withCtx } from "vue";
+// src/notification/NotificationHolder.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["dir"];
+var DEFAULT_THRESHOLD = 3;
+var NotificationHolder_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmNotificationHolder",
+	inheritAttrs: false,
+	__name: "NotificationHolder",
+	props: {
+		notices: { default: () => [] },
+		top: {},
+		bottom: {},
+		zIndex: {},
+		stack: {
+			type: [Boolean, Object],
+			default: void 0
+		},
+		getContainer: {}
+	},
+	emits: ["close"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const edges = ["top", "bottom"];
+		const rootRef = ref();
+		/** the holder is client-only: nothing is rendered on the server */
+		const mounted = ref(false);
+		onMounted(() => {
+			mounted.value = true;
+		});
+		/** per edge, the newest notification first (it sits next to the screen edge) */
+		const lists = computed(() => {
+			const result = {
+				top: [],
+				bottom: []
+			};
+			props.notices.forEach((notice) => result[notice.placement].unshift(notice));
+			return result;
+		});
+		const threshold = computed(() => {
+			const { stack } = props;
+			if (stack === false) return 0;
+			return (typeof stack === "object" ? stack.threshold : void 0) ?? DEFAULT_THRESHOLD;
+		});
+		/** a stack opened by a tap; it folds again on an outside tap or once it is short enough */
+		const expanded = reactive({
+			top: false,
+			bottom: false
+		});
+		function isStacked(edge) {
+			return threshold.value > 0 && lists.value[edge].length > threshold.value;
+		}
+		function isCollapsed(edge) {
+			return isStacked(edge) && !expanded[edge];
+		}
+		watch(() => edges.map(isStacked), (stacked) => {
+			edges.forEach((edge, index) => {
+				if (!stacked[index]) expanded[edge] = false;
+			});
+		});
+		/** a tap on a folded stack opens it instead of reaching the notification */
+		function onListClick(edge, event) {
+			if (!isCollapsed(edge)) return;
+			event.stopPropagation();
+			expanded[edge] = true;
+		}
+		useClickAway(rootRef, () => {
+			expanded.top = false;
+			expanded.bottom = false;
+		}, { enabled: () => expanded.top || expanded.bottom });
+		const rootStyle = computed(() => {
+			const top = addUnit(props.top);
+			const bottom = addUnit(props.bottom);
+			return [
+				{ zIndex: props.zIndex },
+				top ? { "--am-notification-top": top } : void 0,
+				bottom ? { "--am-notification-bottom": bottom } : void 0
+			];
+		});
+		__expose({ nativeElement: rootRef });
+		return (_ctx, _cache) => {
+			return mounted.value ? (openBlock(), createBlock(unref(Portal_default), {
+				key: 0,
+				"get-container": __props.getContainer
+			}, {
+				default: withCtx(({ theme }) => [createElementVNode("div", mergeProps({
+					ref_key: "rootRef",
+					ref: rootRef
+				}, _ctx.$attrs, {
+					class: ["am-notification", theme.class],
+					style: [theme.style, rootStyle.value],
+					dir: theme.dir
+				}), [(openBlock(), createElementBlock(Fragment, null, renderList(edges, (edge) => {
+					return createVNode(TransitionGroup, {
+						key: edge,
+						tag: "div",
+						name: "am-notification-motion",
+						appear: "",
+						class: normalizeClass(["am-notification-list", [`am-notification-list-${edge}`, {
+							"am-notification-list-stack": isStacked(edge),
+							"am-notification-list-collapsed": isCollapsed(edge)
+						}]]),
+						onClickCapture: ($event) => onListClick(edge, $event)
+					}, {
+						default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(lists.value[edge], (notice, index) => {
+							return openBlock(), createElementBlock("div", {
+								key: notice.id,
+								class: "am-notification-wrapper",
+								style: normalizeStyle({ "--am-notification-index": index })
+							}, [createVNode(Notification_default, mergeProps({ ref_for: true }, notice.props, {
+								class: notice.class,
+								style: notice.style,
+								title: notice.title,
+								description: notice.description,
+								actions: notice.actions,
+								icon: notice.icon,
+								type: notice.type,
+								duration: notice.duration,
+								times: notice.times,
+								"show-progress": notice.showProgress,
+								"pause-on-hover": notice.pauseOnHover,
+								closable: notice.closable,
+								"close-icon": notice.closeIcon,
+								"close-disabled": notice.closeDisabled,
+								placement: edge,
+								role: notice.role,
+								classes: notice.classes,
+								styles: notice.styles,
+								onClick: ($event) => notice.onClick?.($event),
+								onClose: ($event) => emit("close", notice.key)
+							}), null, 16, [
+								"class",
+								"style",
+								"title",
+								"description",
+								"actions",
+								"icon",
+								"type",
+								"duration",
+								"times",
+								"show-progress",
+								"pause-on-hover",
+								"closable",
+								"close-icon",
+								"close-disabled",
+								"placement",
+								"role",
+								"classes",
+								"styles",
+								"onClick",
+								"onClose"
+							])], 4);
+						}), 128))]),
+						_: 2
+					}, 1032, ["class", "onClickCapture"]);
+				}), 64))], 16, _hoisted_1)]),
+				_: 1
+			}, 8, ["get-container"])) : createCommentVNode("", true);
+		};
+	}
+});
+export { NotificationHolder_vue_vue_type_script_setup_true_lang_default as default };

package/dist/notification/api.d.ts

@@ -0,0 +1,3 @@
+import type { NotificationApi } from './interface';
+declare const notification: NotificationApi;
+export default notification;

package/dist/notification/api.js

@@ -0,0 +1,160 @@
+import { inBrowser } from "../_util/index.js";
+import { nextZIndex } from "../_util/hooks/useZIndex.js";
+import { mountComponent } from "../_util/mount.js";
+import NotificationHolder_default from "./NotificationHolder.js";
+import { defineComponent, h, shallowReactive, shallowRef } from "vue";
+// src/notification/api.ts
+var DEFAULT_DURATION = 4.5;
+var seed = 0;
+/** PC corner placements collapse to the edge they belong to */
+function toEdge(placement) {
+	return placement?.startsWith("bottom") ? "bottom" : "top";
+}
+function createManager(config, ensureHolder) {
+	const notices = shallowRef([]);
+	const zIndex = shallowRef();
+	const records = /* @__PURE__ */ new Map();
+	function remove(key, callClose) {
+		const record = records.get(key);
+		if (!record) return;
+		records.delete(key);
+		notices.value = notices.value.filter((n) => n !== record.notice);
+		if (callClose) {
+			record.onClosableClose?.();
+			record.onClose?.();
+		}
+	}
+	const holderProps = () => ({
+		notices: notices.value,
+		zIndex: zIndex.value,
+		top: config.top,
+		bottom: config.bottom,
+		stack: config.stack,
+		getContainer: config.getContainer,
+		onClose: (key) => remove(key, true)
+	});
+	function open(args) {
+		if (!inBrowser) return;
+		ensureHolder(holderProps);
+		const key = args.key ?? `am-notification-${++seed}`;
+		const prev = records.get(key);
+		const closableArg = args.closable ?? config.closable;
+		const closable = typeof closableArg === "object" && closableArg !== null ? closableArg : void 0;
+		const closeIcon = closable?.closeIcon !== void 0 ? closable.closeIcon : args.closeIcon !== void 0 ? args.closeIcon : config.closeIcon;
+		const duration = args.duration ?? config.duration ?? DEFAULT_DURATION;
+		const notice = {
+			id: prev?.notice.id ?? ++seed,
+			key,
+			placement: args.placement || !prev ? toEdge(args.placement ?? config.placement) : prev.notice.placement,
+			times: (prev?.notice.times ?? -1) + 1,
+			duration: typeof duration === "number" && duration > 0 ? duration : 0,
+			title: args.title,
+			description: args.description,
+			actions: args.actions,
+			icon: args.icon,
+			type: args.type,
+			showProgress: args.showProgress ?? config.showProgress,
+			pauseOnHover: args.pauseOnHover ?? config.pauseOnHover,
+			closable: closableArg !== false,
+			closeIcon,
+			closeDisabled: closable?.disabled,
+			role: args.role,
+			class: args.class,
+			style: args.style,
+			classes: {
+				...config.classes,
+				...args.classes
+			},
+			styles: {
+				...config.styles,
+				...args.styles
+			},
+			props: args.props,
+			onClick: args.onClick
+		};
+		records.set(key, {
+			notice,
+			onClose: args.onClose,
+			onClosableClose: closable?.onClose
+		});
+		if (prev) {
+			notices.value = notices.value.map((n) => n === prev.notice ? notice : n);
+			return;
+		}
+		zIndex.value = nextZIndex();
+		notices.value = [...notices.value, notice];
+		const { maxCount } = config;
+		if (typeof maxCount === "number" && maxCount > 0) while (notices.value.length > maxCount) remove(notices.value[0].key, true);
+	}
+	function destroy(key) {
+		if (key !== void 0) {
+			remove(key, false);
+			return;
+		}
+		Array.from(records.keys()).forEach((k) => remove(k, false));
+	}
+	const typeOpen = (type) => (args) => open({
+		...args,
+		type
+	});
+	return {
+		open,
+		destroy,
+		success: typeOpen("success"),
+		error: typeOpen("error"),
+		info: typeOpen("info"),
+		warning: typeOpen("warning"),
+		holderProps
+	};
+}
+var globalOptions = shallowReactive({});
+var holder;
+function ensureStaticHolder(holderProps) {
+	if (holder) {
+		const el = holder.instance?.nativeElement;
+		if (!el || el.isConnected) return;
+		holder.unmount();
+		holder = void 0;
+	}
+	const current = {
+		unmount: () => {},
+		instance: void 0
+	};
+	holder = current;
+	current.unmount = mountComponent(() => h(NotificationHolder_default, {
+		...holderProps(),
+		ref: (instance) => {
+			if (instance) current.instance = instance;
+		}
+	}), globalOptions.appContext).unmount;
+}
+var staticManager = createManager(globalOptions, ensureStaticHolder);
+function pickInstance(manager) {
+	const { open, destroy, success, error, info, warning } = manager;
+	return {
+		open,
+		destroy,
+		success,
+		error,
+		info,
+		warning
+	};
+}
+function useNotification(config = {}) {
+	const manager = createManager(config, () => {});
+	const ContextHolder = defineComponent({
+		name: "AmNotificationContextHolder",
+		setup() {
+			return () => h(NotificationHolder_default, manager.holderProps());
+		}
+	});
+	return [pickInstance(manager), ContextHolder];
+}
+var notification = {
+	...pickInstance(staticManager),
+	config(options) {
+		Object.assign(globalOptions, options);
+	},
+	useNotification
+};
+export { notification as default };

package/dist/notification/index.d.ts

@@ -0,0 +1,3 @@
+import notification from './api';
+export type * from './interface';
+export default notification;

package/dist/notification/index.js

@@ -0,0 +1,4 @@
+import notification from "./api.js";
+// src/notification/index.ts
+var notification_default = notification;
+export { notification_default as default };