@omerdlw/base-framework 1.0.0

package/dist/modules/notification/index.js

@@ -0,0 +1,905 @@
+"use client";
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { createContext, useState, useRef, useCallback, useEffect, useMemo, use, useSyncExternalStore, useLayoutEffect, useContext } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import 'next/navigation';
+import { createPortal } from 'react-dom';
+import { AnimatePresence, motion } from 'motion/react';
+
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/utils/dom.ts
+var isBrowser = typeof window !== "undefined";
+
+// src/utils/object.ts
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function report(scope, error, level = "error") {
+  if (process.env.NODE_ENV === "production" && typeof window !== "undefined") {
+    return;
+  }
+  console[level](`[${scope}]`, error);
+}
+
+// src/utils/user-message.ts
+var USER_MESSAGES = Object.freeze({
+  generic: "Something went wrong. Please try again",
+  network: "You appear to be offline. Check your connection and try again",
+  timeout: "That took too long. Please try again",
+  unauthorized: "Your session has expired. Please sign in again",
+  forbidden: "You don't have permission to do that",
+  notFound: "We couldn't find what you were looking for",
+  rateLimited: "Too many attempts. Please wait a moment and try again",
+  server: "We're having trouble on our end. Please try again in a moment"
+});
+var UserError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "UserError";
+    this.status = status;
+  }
+};
+var NETWORK_FAILURE = /failed to fetch|network|load failed|fetch failed/i;
+function readField(source, field, type) {
+  const value = source?.[field];
+  return typeof value === type ? value : void 0;
+}
+function readPayloadMessage(error) {
+  const payload = error?.payload;
+  const message = readField(payload, "error", "string")?.trim();
+  return message || void 0;
+}
+function toUserMessage(error, { codes, fallback = USER_MESSAGES.generic } = {}) {
+  if (typeof error === "string") return error.trim() || fallback;
+  if (!error || typeof error !== "object") return fallback;
+  if (error instanceof UserError) {
+    if (error.status === 401) return USER_MESSAGES.unauthorized;
+    return error.message || fallback;
+  }
+  if (error.name === "AbortError") return fallback;
+  const code = readField(error, "code", "string");
+  if (code && codes?.[code]) return codes[code];
+  const status = readField(error, "status", "number");
+  if (status === 401) return USER_MESSAGES.unauthorized;
+  if (status === 429) return USER_MESSAGES.rateLimited;
+  if (status === 408 || status === 504) return USER_MESSAGES.timeout;
+  if (status !== void 0 && status >= 500) return USER_MESSAGES.server;
+  if (status !== void 0 && status >= 400) {
+    const authored = readPayloadMessage(error);
+    if (authored) return authored;
+    if (status === 403) return USER_MESSAGES.forbidden;
+    if (status === 404) return USER_MESSAGES.notFound;
+    return fallback;
+  }
+  const isOffline = typeof navigator !== "undefined" && navigator.onLine === false;
+  if (isOffline || NETWORK_FAILURE.test(error.message ?? "") && (error instanceof TypeError || /fetch/i.test(error.name))) {
+    return USER_MESSAGES.network;
+  }
+  return fallback;
+}
+
+// src/utils/store.ts
+function freezeStoreSnapshot(state) {
+  if (process.env.NODE_ENV === "production" || !state || typeof state !== "object") {
+    return state;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const freeze = (value) => {
+    if (seen.has(value) || Object.isFrozen(value)) return;
+    seen.add(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (Array.isArray(value) || prototype === Object.prototype || prototype === null) {
+      for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor && "value" in descriptor && descriptor.value !== null) {
+          if (typeof descriptor.value === "object") freeze(descriptor.value);
+        }
+      }
+    }
+    Object.freeze(value);
+  };
+  freeze(state);
+  return state;
+}
+function createStore(initialState, { freezeSnapshots = true } = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const prepare = freezeSnapshots ? freezeStoreSnapshot : (state) => state;
+  let snapshot = prepare(initialState);
+  const publish = (nextStateOrUpdater) => {
+    const nextState = typeof nextStateOrUpdater === "function" ? nextStateOrUpdater(snapshot) : nextStateOrUpdater;
+    if (Object.is(snapshot, nextState)) return false;
+    snapshot = prepare(nextState);
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch (error) {
+        report("CoreStore subscriber", error, "warn");
+      }
+    }
+    return true;
+  };
+  const setState = (updater) => {
+    if (typeof updater === "function") {
+      return publish(updater);
+    }
+    if (snapshot && typeof snapshot === "object" && updater && typeof updater === "object") {
+      return publish({ ...snapshot, ...updater });
+    }
+    return publish(updater);
+  };
+  return Object.freeze({
+    getSnapshot() {
+      return snapshot;
+    },
+    publish,
+    setState,
+    subscribe(listener) {
+      if (typeof listener !== "function") return () => {
+      };
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  });
+}
+function getOrCreateGlobalContext(name, defaultValue) {
+  const sym = /* @__PURE__ */ Symbol.for(`@omerdlw/base-framework/context/${name}`);
+  const store = globalThis;
+  if (!store[sym]) {
+    store[sym] = createContext(defaultValue);
+  }
+  return store[sym];
+}
+
+// src/theme.tsx
+function defineThemeSpec(id) {
+  return Object.freeze({ id });
+}
+var EMPTY = /* @__PURE__ */ new Map();
+var ThemeContext = getOrCreateGlobalContext("ThemeContext", EMPTY);
+function useTheme(spec) {
+  const config = useContext(ThemeContext).get(spec.id);
+  if (!config) {
+    throw new Error(
+      `Theme "${spec.id}" is missing. Add its theme file to src/config/ and list it in src/config/index.ts.`
+    );
+  }
+  return {
+    slots: config.slots,
+    styles: config.styles ?? {}
+  };
+}
+
+// src/modules/notification/constants.ts
+var TOAST_DURATIONS = Object.freeze({
+  DEFAULT: 2e3,
+  SHORT: 1500
+});
+var SESSION_EXPIRED_MESSAGE = USER_MESSAGES.unauthorized;
+var DOCK_STACK_ELEMENT_ID = "dock-card-stack";
+var notificationTheme = defineThemeSpec("notification");
+function useRequiredContext(context, hookName, providerName) {
+  const value = use(context);
+  if (value === null) {
+    throw new Error(`${hookName} must be used within ${providerName}`);
+  }
+  return value;
+}
+function useStore(store, selector = (state) => state, isEqual = Object.is) {
+  const cacheRef = useRef({
+    isEqual: null,
+    selected: void 0,
+    selector: null,
+    snapshot: null
+  });
+  const getSelectedSnapshot = useCallback(() => {
+    const snapshot = store.getSnapshot();
+    const cache = cacheRef.current;
+    if (cache.snapshot === snapshot && cache.selector === selector && cache.isEqual === isEqual) {
+      return cache.selected;
+    }
+    const selected = selector(snapshot);
+    if (cache.snapshot !== null && cache.isEqual === isEqual && isEqual(cache.selected, selected)) {
+      cache.snapshot = snapshot;
+      cache.selector = selector;
+      return cache.selected;
+    }
+    cacheRef.current = {
+      isEqual,
+      selected,
+      selector,
+      snapshot
+    };
+    return selected;
+  }, [isEqual, selector, store]);
+  return useSyncExternalStore(
+    store.subscribe,
+    getSelectedSnapshot,
+    getSelectedSnapshot
+  );
+}
+var useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;
+
+// src/events.ts
+var EVENT_TYPES = Object.freeze({
+  API_UNAUTHORIZED: "API_UNAUTHORIZED",
+  STATE_CHANGE: "STATE_CHANGE",
+  API_ERROR: "API_ERROR",
+  APP_ERROR: "APP_ERROR"
+});
+var EventEmitter = class {
+  events = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  subscribe(event, callback) {
+    if (typeof event !== "string" || !event || typeof callback !== "function") {
+      return () => {
+      };
+    }
+    const listeners = this.events.get(event) || /* @__PURE__ */ new Set();
+    listeners.add(callback);
+    this.events.set(event, listeners);
+    return () => {
+      listeners.delete(callback);
+      if (listeners.size === 0) this.events.delete(event);
+    };
+  }
+  emit(event, payload) {
+    const listeners = this.events.get(event);
+    if (!listeners || listeners.size === 0) return;
+    const snapshot = Array.from(listeners);
+    for (const callback of snapshot) {
+      try {
+        callback(payload);
+      } catch (error) {
+        report(`Event listener (${String(event)})`, error);
+      }
+    }
+  }
+  emitDebounced(event, payload, waitMs = 100) {
+    const existing = this.debounceTimers.get(event);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(event);
+      this.emit(event, payload);
+    }, waitMs);
+    this.debounceTimers.set(event, timer);
+  }
+  cancelDebounced(event) {
+    if (event) {
+      const timer = this.debounceTimers.get(event);
+      if (timer) {
+        clearTimeout(timer);
+        this.debounceTimers.delete(event);
+      }
+    } else {
+      for (const timer of this.debounceTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.debounceTimers.clear();
+    }
+  }
+  unsubscribeAll(event) {
+    this.cancelDebounced(event);
+    if (event) this.events.delete(event);
+    else this.events.clear();
+  }
+  hasListeners(event) {
+    return Boolean(this.events.get(event)?.size);
+  }
+  getListenerCount(event) {
+    return this.events.get(event)?.size || 0;
+  }
+  getAllEvents() {
+    return [...this.events.keys()];
+  }
+};
+var GLOBAL_EVENTS_KEY = /* @__PURE__ */ Symbol.for("__base_framework_global_events__");
+var _global = globalThis;
+var globalEvents = _global[GLOBAL_EVENTS_KEY] ?? (_global[GLOBAL_EVENTS_KEY] = new EventEmitter());
+
+// src/hooks/use-global-event.ts
+function useGlobalEvent(event, callback, options) {
+  const callbackRef = useRef(callback);
+  const debounceTimerRef = useRef(null);
+  useRef(0);
+  const throttleTimerRef = useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    callbackRef.current = callback;
+  });
+  const debounceMs = options?.debounceMs;
+  const throttleMs = options?.throttleMs;
+  useEffect(() => {
+    if (!event) return;
+    const events = Array.isArray(event) ? event.filter(Boolean) : [event];
+    if (events.length === 0) return;
+    const handler = (payload) => {
+      callbackRef.current?.(payload);
+    };
+    const unsubs = events.map((ev) => globalEvents.subscribe(ev, handler));
+    return () => {
+      unsubs.forEach((unsub) => unsub());
+      if (debounceTimerRef.current !== null) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = null;
+      }
+      if (throttleTimerRef.current !== null) {
+        clearTimeout(throttleTimerRef.current);
+        throttleTimerRef.current = null;
+      }
+    };
+  }, [event, debounceMs, throttleMs]);
+}
+
+// src/result.ts
+function isResult(value) {
+  return typeof value === "object" && value !== null && "success" in value && typeof value.success === "boolean" && ("data" in value && value.success === true || "error" in value && value.success === false);
+}
+
+// src/modules/notification/utils.ts
+function normalizeFeedbackText(value) {
+  if (typeof value !== "string") return value;
+  return value.trim().replace(/[.\s]+$/, "");
+}
+function getActiveNotification(notifications) {
+  let active = null;
+  for (const entry of Object.values(notifications)) {
+    if (!active || entry.timestamp >= active.timestamp) active = entry;
+  }
+  return active;
+}
+function normalizeToastOptions(options) {
+  return typeof options === "number" ? { duration: options } : options || {};
+}
+function withDefaultDuration(duration, options) {
+  const normalized = normalizeToastOptions(options);
+  return {
+    ...normalized,
+    duration: normalized.duration !== void 0 ? normalized.duration : duration
+  };
+}
+function isNotificationDataObject(value) {
+  return isObject(value) && "message" in value;
+}
+var NotificationContext = getOrCreateGlobalContext(
+  "NotificationContext",
+  null
+);
+var notificationIdCounter = 0;
+var INITIAL_NOTIFICATION_STATE = { notifications: {} };
+function normalizeDuration(value) {
+  if (value === null) return null;
+  if (value === void 0) return TOAST_DURATIONS.DEFAULT;
+  const duration = Number(value);
+  return Number.isFinite(duration) && duration > 0 ? duration : null;
+}
+var NotificationProvider = ({
+  children
+}) => {
+  const [store] = useState(
+    () => createStore(INITIAL_NOTIFICATION_STATE, {
+      freezeSnapshots: false
+    })
+  );
+  const timersRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const clearTimers = useCallback(() => {
+    timersRef.current.forEach(clearTimeout);
+    timersRef.current.clear();
+  }, []);
+  useEffect(() => clearTimers, [clearTimers]);
+  const dismissNotification = useCallback(
+    (id) => {
+      clearTimeout(timersRef.current.get(id));
+      timersRef.current.delete(id);
+      store.publish((prev) => {
+        if (!Object.hasOwn(prev.notifications, id)) return prev;
+        const notifications = { ...prev.notifications };
+        delete notifications[id];
+        return { notifications };
+      });
+    },
+    [store]
+  );
+  const dismissAllNotifications = useCallback(() => {
+    clearTimers();
+    store.publish(
+      (prev) => Object.keys(prev.notifications).length === 0 ? prev : { notifications: {} }
+    );
+  }, [clearTimers, store]);
+  const showNotification = useCallback(
+    (messageOrData, options) => {
+      const normalizedOptions = normalizeToastOptions(options);
+      const payload = isNotificationDataObject(messageOrData) ? { ...normalizedOptions, ...messageOrData } : { ...normalizedOptions, message: messageOrData };
+      const normalizedMessage = normalizeFeedbackText(payload.message);
+      if (normalizedMessage === null || normalizedMessage === void 0 || normalizedMessage === "") {
+        return null;
+      }
+      const id = payload.dedupeKey || payload.id || (typeof normalizedMessage === "string" ? normalizedMessage.slice(0, 64) : `notification-${++notificationIdCounter}`);
+      clearTimers();
+      const entry = {
+        dedupeKey: payload.dedupeKey,
+        duration: payload.duration,
+        id,
+        message: normalizedMessage,
+        timestamp: Date.now()
+      };
+      store.publish({ notifications: { [id]: entry } });
+      const duration = normalizeDuration(payload.duration);
+      if (duration) {
+        timersRef.current.set(
+          id,
+          setTimeout(() => dismissNotification(id), duration)
+        );
+      }
+      return id;
+    },
+    [clearTimers, dismissNotification, store]
+  );
+  const actions = useMemo(
+    () => ({
+      dismissAllNotifications,
+      dismissNotification,
+      showNotification
+    }),
+    [dismissAllNotifications, dismissNotification, showNotification]
+  );
+  const value = useMemo(
+    () => ({ actions, store }),
+    [actions, store]
+  );
+  return /* @__PURE__ */ jsx(NotificationContext, { value, children });
+};
+function useNotificationActions() {
+  return useRequiredContext(
+    NotificationContext,
+    "useNotificationActions",
+    "NotificationProvider"
+  ).actions;
+}
+function useNotificationState() {
+  const { store } = useRequiredContext(
+    NotificationContext,
+    "useNotificationState",
+    "NotificationProvider"
+  );
+  return useStore(store);
+}
+function useNotification() {
+  const actions = useNotificationActions();
+  const state = useNotificationState();
+  return useMemo(() => ({ ...actions, ...state }), [actions, state]);
+}
+var toastPromiseIdCounter = 0;
+function resolveMessage(message, arg) {
+  return typeof message === "function" ? message(arg) : message;
+}
+function getOutcomeMessage(value, messages) {
+  if (!isResult(value)) return resolveMessage(messages.success, value);
+  return value.success ? resolveMessage(messages.success, value.data) : resolveMessage(messages.error, value.error) || toUserMessage(value.error);
+}
+function useToast(defaultDuration) {
+  const { dismissAllNotifications, dismissNotification, showNotification } = useNotificationActions();
+  const resolvedDefaultDuration = defaultDuration ?? TOAST_DURATIONS.DEFAULT;
+  const triggerToast = useCallback(
+    (message, options) => showNotification(
+      message,
+      withDefaultDuration(resolvedDefaultDuration, options)
+    ),
+    [resolvedDefaultDuration, showNotification]
+  );
+  const dismiss = useCallback(
+    (id) => {
+      if (id) dismissNotification(id);
+      else dismissAllNotifications();
+    },
+    [dismissAllNotifications, dismissNotification]
+  );
+  const fromResult = useCallback(
+    (result, messages = {}, options) => {
+      if (isResult(result)) {
+        const message = getOutcomeMessage(result, messages);
+        if (message) triggerToast(message, options);
+      }
+      return result;
+    },
+    [triggerToast]
+  );
+  const promise = useCallback(
+    async (promiseOrFn, messages = {}, options) => {
+      const normalized = normalizeToastOptions(options);
+      const id = normalized.id || normalized.dedupeKey || `toast-promise-${++toastPromiseIdCounter}`;
+      const sharedOptions = { ...normalized, id };
+      if (messages.loading) {
+        showNotification(messages.loading, {
+          ...sharedOptions,
+          duration: null
+        });
+      }
+      try {
+        const resolved = await (typeof promiseOrFn === "function" ? promiseOrFn() : promiseOrFn);
+        const message = getOutcomeMessage(resolved, messages);
+        if (message) triggerToast(message, sharedOptions);
+        else if (messages.loading) dismiss(id);
+        return resolved;
+      } catch (error) {
+        triggerToast(
+          resolveMessage(messages.error, error) || toUserMessage(error),
+          sharedOptions
+        );
+        throw error;
+      }
+    },
+    [dismiss, showNotification, triggerToast]
+  );
+  return useMemo(
+    () => Object.assign(
+      (message, options) => triggerToast(message, options),
+      { dismiss, dismissAll: dismissAllNotifications, fromResult, promise }
+    ),
+    [dismiss, dismissAllNotifications, fromResult, promise, triggerToast]
+  );
+}
+var emptySubscribe = () => () => {
+};
+function NotificationListener() {
+  const { showNotification } = useNotificationActions();
+  useGlobalEvent(EVENT_TYPES.API_UNAUTHORIZED, (data) => {
+    if (data?.source && data.source !== "app") return;
+    showNotification(SESSION_EXPIRED_MESSAGE);
+  });
+  useGlobalEvent(
+    EVENT_TYPES.APP_ERROR,
+    (data) => {
+      if (!data?.notify || !data.message) return;
+      showNotification(data.message);
+    }
+  );
+  useGlobalEvent(
+    EVENT_TYPES.STATE_CHANGE,
+    (data) => {
+      if (!data?.notify || !data.message) return;
+      showNotification(data.message);
+    }
+  );
+  return null;
+}
+function useNotificationContainerModel() {
+  const { notifications } = useNotificationState();
+  const { dismissNotification } = useNotificationActions();
+  const isHydrated = useSyncExternalStore(
+    emptySubscribe,
+    () => true,
+    () => false
+  );
+  const activeEntry = useMemo(
+    () => getActiveNotification(notifications),
+    [notifications]
+  );
+  const theme = useTheme(notificationTheme);
+  return { dismissNotification, isHydrated, activeEntry, theme };
+}
+
+// src/kernel/constants.ts
+var REGISTRY_SOURCES = Object.freeze({
+  STATIC: "static",
+  DYNAMIC: "dynamic",
+  USER: "user"
+});
+var REGISTRY_LIFECYCLES = Object.freeze({
+  IMMEDIATE: "immediate",
+  GRACEFUL: "graceful",
+  PERSISTENT: "persistent",
+  ROUTE: "route"
+});
+var REGISTRY_METADATA_KEYS = Object.freeze([
+  "cleanup",
+  "cleanupDelayMs",
+  "instanceId",
+  "lifecycle",
+  "priority",
+  "source",
+  "scope",
+  "validation"
+]);
+Object.freeze({
+  [REGISTRY_SOURCES.STATIC]: 100,
+  [REGISTRY_SOURCES.DYNAMIC]: 200,
+  [REGISTRY_SOURCES.USER]: 300
+});
+Object.freeze({
+  [REGISTRY_SOURCES.STATIC]: 10,
+  [REGISTRY_SOURCES.DYNAMIC]: 20,
+  [REGISTRY_SOURCES.USER]: 30
+});
+new Set(
+  Object.values(REGISTRY_LIFECYCLES)
+);
+new Set(
+  REGISTRY_METADATA_KEYS
+);
+var REGISTRY_SCOPE_KINDS = Object.freeze({
+  APP: "app",
+  SESSION: "session",
+  ROUTE: "route",
+  INSTANCE: "instance",
+  WORKSPACE: "workspace"
+});
+REGISTRY_SCOPE_KINDS.APP;
+function createNoopHandle(status = "rejected", reason = "unknown") {
+  const handle = Object.assign(() => false, {
+    active: false,
+    dispose: () => false,
+    instanceId: null,
+    key: "",
+    priority: 0,
+    reason,
+    source: "",
+    status,
+    type: "",
+    update: () => handle,
+    updatedAt: 0,
+    validation: "warn"
+  });
+  return handle;
+}
+createNoopHandle();
+getOrCreateGlobalContext(
+  "RegistryContext",
+  null
+);
+getOrCreateGlobalContext("ModuleHostContext", null);
+function createPageControllerStore() {
+  const listeners = /* @__PURE__ */ new Set();
+  let stack = [];
+  const notify = () => {
+    listeners.forEach((listener) => {
+      try {
+        listener();
+      } catch (error) {
+        report("Page controller listener", error);
+      }
+    });
+  };
+  return {
+    getSnapshot() {
+      const top = stack[stack.length - 1];
+      return top?.controllerRef?.current || null;
+    },
+    notify,
+    register(id, controllerRef) {
+      stack = stack.filter((item) => item.id !== id);
+      stack.push({ controllerRef, id });
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    unregister(id) {
+      stack = stack.filter((item) => item.id !== id);
+      notify();
+    }
+  };
+}
+var fallbackStandaloneStore = createPageControllerStore();
+getOrCreateGlobalContext(
+  "PageControllerContext",
+  null
+);
+getOrCreateGlobalContext(
+  "PageControllerStoreContext",
+  fallbackStandaloneStore
+);
+function defineModule(coreModule) {
+  return Object.freeze({ ...coreModule });
+}
+createStore(void 0);
+
+// src/tokens/motion.ts
+var DURATION_TOKENS = Object.freeze({
+  INSTANT: 0.08,
+  MICRO: 0.18,
+  FAST: 0.28,
+  BASE: 0.36,
+  MODERATE: 0.44,
+  SLOW: 0.58,
+  CINEMATIC: 0.86
+});
+var EASING_CURVES = Object.freeze({
+  OUT_EXPO: [0.16, 1, 0.3, 1],
+  OUT_QUART: [0.25, 1, 0.5, 1],
+  OUT_QUINT: [0.22, 1, 0.36, 1],
+  IN_OUT_CUBIC: [0.65, 0, 0.35, 1],
+  IN_CUBIC: [0.5, 0, 1, 1],
+  OUT_BACK: [0.34, 1.56, 0.64, 1]
+});
+var MOTION_EASINGS = Object.freeze({
+  ENTER: EASING_CURVES.OUT_QUART,
+  ENTER_EMPHASIZED: EASING_CURVES.OUT_EXPO,
+  EXIT: EASING_CURVES.IN_CUBIC
+});
+Object.freeze({
+  MICRO: Object.freeze({
+    distance: 4,
+    duration: DURATION_TOKENS.MICRO,
+    ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+    scaleDelta: 8e-3
+  }),
+  FAST: Object.freeze({
+    distance: 9,
+    duration: DURATION_TOKENS.FAST,
+    ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+    scaleDelta: 0.012
+  }),
+  STANDARD: Object.freeze({
+    distance: 18,
+    duration: DURATION_TOKENS.MODERATE,
+    ease: MOTION_EASINGS.ENTER,
+    scaleDelta: 0.018
+  }),
+  SURFACE: Object.freeze({
+    distance: 28,
+    duration: DURATION_TOKENS.SLOW,
+    ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+    scaleDelta: 0.024
+  })
+});
+Object.freeze({
+  duration: DURATION_TOKENS.INSTANT,
+  ease: "linear"
+});
+
+// src/modules/notification/motion.ts
+function toGpuTransform(y = 0, scale = 1) {
+  return `translate3d(0, ${Math.round(y)}px, 0) scale(${Math.round(scale * 1e3) / 1e3})`;
+}
+var NOTIFICATION_COMPOSITOR_STYLE = Object.freeze({
+  WebkitBackfaceVisibility: "hidden",
+  WebkitFontSmoothing: "antialiased",
+  backfaceVisibility: "hidden",
+  transform: "translateZ(0)",
+  willChange: "transform, opacity, filter"
+});
+var NOTIFICATION_TRANSITION = Object.freeze({
+  duration: DURATION_TOKENS.MODERATE,
+  ease: EASING_CURVES.OUT_EXPO,
+  type: "tween"
+});
+var NOTIFICATION_EXIT_TRANSITION = Object.freeze({
+  duration: DURATION_TOKENS.FAST,
+  ease: EASING_CURVES.IN_CUBIC,
+  type: "tween"
+});
+var toastVariants = Object.freeze({
+  exit: {
+    opacity: 0,
+    transform: toGpuTransform(-6, 0.98),
+    transition: NOTIFICATION_EXIT_TRANSITION
+  },
+  hidden: {
+    opacity: 0,
+    transform: toGpuTransform(-10, 0.96)
+  },
+  visible: {
+    opacity: 1,
+    transform: toGpuTransform(0, 1),
+    transition: NOTIFICATION_TRANSITION
+  }
+});
+function Toast({
+  className,
+  entry,
+  messageClassName,
+  onDismiss,
+  polite,
+  style
+}) {
+  return /* @__PURE__ */ jsx(
+    motion.div,
+    {
+      role: "alert",
+      "aria-atomic": "true",
+      "aria-live": polite ? "polite" : void 0,
+      "aria-keyshortcuts": "Escape",
+      tabIndex: 0,
+      variants: toastVariants,
+      initial: "hidden",
+      animate: "visible",
+      exit: "exit",
+      transition: NOTIFICATION_TRANSITION,
+      style: { ...NOTIFICATION_COMPOSITOR_STYLE, ...style },
+      className,
+      onClick: (event) => {
+        event.stopPropagation();
+        onDismiss();
+      },
+      onKeyDown: (event) => {
+        if (event.key !== "Escape") return;
+        event.preventDefault();
+        event.stopPropagation();
+        onDismiss();
+      },
+      children: /* @__PURE__ */ jsx("div", { className: messageClassName, children: entry.message })
+    }
+  );
+}
+function NotificationContainer() {
+  const { dismissNotification, isHydrated, activeEntry, theme } = useNotificationContainerModel();
+  if (!isHydrated) return null;
+  const dockElement = document.getElementById(DOCK_STACK_ELEMENT_ID);
+  const toast = (className, polite) => /* @__PURE__ */ jsx(AnimatePresence, { mode: "wait", children: activeEntry && /* @__PURE__ */ jsx(
+    Toast,
+    {
+      className,
+      entry: activeEntry,
+      messageClassName: theme.slots.toastMessage,
+      polite,
+      style: theme.styles.toast,
+      onDismiss: () => dismissNotification(activeEntry.id)
+    },
+    activeEntry.id
+  ) });
+  if (dockElement) {
+    return createPortal(
+      toast(cn(theme.slots.toast, theme.slots.toastDocked), true),
+      dockElement
+    );
+  }
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        "aria-atomic": "true",
+        "aria-live": "polite",
+        className: theme.slots.layer,
+        style: theme.styles.layer,
+        children: toast(theme.slots.toast)
+      }
+    ),
+    document.body
+  );
+}
+function NotificationLayer() {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(NotificationListener, {}),
+    /* @__PURE__ */ jsx(NotificationContainer, {})
+  ] });
+}
+
+// src/modules/notification/module.ts
+function selectToastDuration(config) {
+  const notification = config.notification;
+  if (typeof notification === "number") return notification;
+  return notification?.duration ?? null;
+}
+function useNotificationPage(duration, page) {
+  const toast = useToast(duration);
+  return useMemo(
+    () => ({
+      set: (notification) => page.set({ notification }),
+      toast
+    }),
+    [page, toast]
+  );
+}
+var notificationModule = defineModule({
+  id: "notification",
+  context: NotificationContext,
+  Provider: NotificationProvider,
+  Overlay: NotificationLayer,
+  page: {
+    select: selectToastDuration,
+    use: useNotificationPage
+  }
+});
+
+export { NotificationContext, NotificationProvider, TOAST_DURATIONS, notificationModule, notificationTheme, useNotification, useNotificationActions, useNotificationState, useToast };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map