@theaccessibleteam/a11y-feedback-svelte 2.0.0

package/dist/index.cjs

@@ -0,0 +1,211 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createA11yFeedbackStore: () => createA11yFeedbackStore,
+  useA11yAnnounce: () => useA11yAnnounce,
+  useA11yFeedback: () => useA11yFeedback,
+  useFeedbackConfig: () => useFeedbackConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/useA11yFeedback.ts
+var import_store = require("svelte/store");
+var import_a11y_feedback = require("@theaccessibleteam/a11y-feedback");
+function useA11yFeedback() {
+  const state = (0, import_store.writable)({
+    notifications: (0, import_a11y_feedback.getNotificationHistory)(),
+    unreadCount: (0, import_a11y_feedback.getUnreadCount)()
+  });
+  const updateState = () => {
+    state.set({
+      notifications: (0, import_a11y_feedback.getNotificationHistory)(),
+      unreadCount: (0, import_a11y_feedback.getUnreadCount)()
+    });
+  };
+  (0, import_a11y_feedback.onFeedback)("announced", updateState);
+  (0, import_a11y_feedback.onFeedback)("dismissed", updateState);
+  (0, import_a11y_feedback.onFeedback)("replaced", updateState);
+  return {
+    subscribe: state.subscribe,
+    notify: async (message, type, options) => {
+      const result = await (0, import_a11y_feedback.notify)({ message, type, options });
+      updateState();
+      return result;
+    },
+    success: async (message, options) => {
+      const result = await import_a11y_feedback.notify.success(message, options);
+      updateState();
+      return result;
+    },
+    error: async (message, options) => {
+      const result = await import_a11y_feedback.notify.error(message, options);
+      updateState();
+      return result;
+    },
+    warning: async (message, options) => {
+      const result = await import_a11y_feedback.notify.warning(message, options);
+      updateState();
+      return result;
+    },
+    info: async (message, options) => {
+      const result = await import_a11y_feedback.notify.info(message, options);
+      updateState();
+      return result;
+    },
+    loading: async (message, options) => {
+      const result = await import_a11y_feedback.notify.loading(message, options);
+      updateState();
+      return result;
+    },
+    dismiss: (id) => {
+      (0, import_a11y_feedback.dismissVisualFeedback)(id);
+      updateState();
+    },
+    dismissAll: () => {
+      (0, import_a11y_feedback.dismissAllVisualFeedback)();
+      updateState();
+    },
+    destroy: () => {
+    }
+  };
+}
+
+// src/useA11yAnnounce.ts
+var import_a11y_feedback2 = require("@theaccessibleteam/a11y-feedback");
+function useA11yAnnounce() {
+  return {
+    success: async (message, options) => {
+      await import_a11y_feedback2.notify.success(message, options);
+    },
+    error: async (message, options) => {
+      await import_a11y_feedback2.notify.error(message, options);
+    },
+    warning: async (message, options) => {
+      await import_a11y_feedback2.notify.warning(message, options);
+    },
+    info: async (message, options) => {
+      await import_a11y_feedback2.notify.info(message, options);
+    },
+    loading: async (message, options) => {
+      await import_a11y_feedback2.notify.loading(message, options);
+    }
+  };
+}
+
+// src/useFeedbackConfig.ts
+var import_store2 = require("svelte/store");
+var import_a11y_feedback3 = require("@theaccessibleteam/a11y-feedback");
+function useFeedbackConfig() {
+  const store = (0, import_store2.writable)((0, import_a11y_feedback3.getConfig)());
+  return {
+    subscribe: store.subscribe,
+    update: (config) => {
+      (0, import_a11y_feedback3.configureFeedback)(config);
+      store.set((0, import_a11y_feedback3.getConfig)());
+    },
+    reset: () => {
+      (0, import_a11y_feedback3.resetConfig)();
+      store.set((0, import_a11y_feedback3.getConfig)());
+    }
+  };
+}
+
+// src/store.ts
+var import_store3 = require("svelte/store");
+var import_a11y_feedback4 = require("@theaccessibleteam/a11y-feedback");
+function createA11yFeedbackStore() {
+  const { subscribe, set, update } = (0, import_store3.writable)({
+    notifications: (0, import_a11y_feedback4.getNotificationHistory)(),
+    unreadCount: (0, import_a11y_feedback4.getUnreadCount)(),
+    config: (0, import_a11y_feedback4.getConfig)()
+  });
+  const handleFeedback = () => {
+    update((state) => ({
+      ...state,
+      notifications: (0, import_a11y_feedback4.getNotificationHistory)(),
+      unreadCount: (0, import_a11y_feedback4.getUnreadCount)()
+    }));
+  };
+  (0, import_a11y_feedback4.onFeedback)("announced", handleFeedback);
+  (0, import_a11y_feedback4.onFeedback)("dismissed", handleFeedback);
+  return {
+    subscribe,
+    /**
+     * Send a notification
+     */
+    notify: async (message, type, options) => {
+      return (0, import_a11y_feedback4.notify)({ message, type, options });
+    },
+    /**
+     * Send a success notification
+     */
+    success: async (message, options) => {
+      return import_a11y_feedback4.notify.success(message, options);
+    },
+    /**
+     * Send an error notification
+     */
+    error: async (message, options) => {
+      return import_a11y_feedback4.notify.error(message, options);
+    },
+    /**
+     * Send a warning notification
+     */
+    warning: async (message, options) => {
+      return import_a11y_feedback4.notify.warning(message, options);
+    },
+    /**
+     * Send an info notification
+     */
+    info: async (message, options) => {
+      return import_a11y_feedback4.notify.info(message, options);
+    },
+    /**
+     * Send a loading notification
+     */
+    loading: async (message, options) => {
+      return import_a11y_feedback4.notify.loading(message, options);
+    },
+    /**
+     * Update configuration
+     */
+    configure: (config) => {
+      (0, import_a11y_feedback4.configureFeedback)(config);
+      update((state) => ({
+        ...state,
+        config: (0, import_a11y_feedback4.getConfig)()
+      }));
+    },
+    /**
+     * Cleanup subscriptions
+     */
+    destroy: () => {
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createA11yFeedbackStore,
+  useA11yAnnounce,
+  useA11yFeedback,
+  useFeedbackConfig
+});

package/dist/index.d.cts

@@ -0,0 +1,114 @@
+import * as svelte_store from 'svelte/store';
+import { Readable } from 'svelte/store';
+import { FeedbackEvent, FeedbackType, FeedbackOptions, FeedbackConfig } from '@theaccessibleteam/a11y-feedback';
+export { ConfirmOptions, FeedbackConfig, FeedbackEvent, FeedbackOptions, FeedbackType, NotificationAction, ProgressController, ProgressOptions, PromptOptions, RichContent } from '@theaccessibleteam/a11y-feedback';
+
+/**
+ * Main hook for a11y-feedback in Svelte
+ */
+
+/**
+ * A11y Feedback store interface
+ */
+interface A11yFeedbackStore extends Readable<{
+    notifications: readonly FeedbackEvent[];
+    unreadCount: number;
+}> {
+    notify: (message: string, type: FeedbackType, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    success: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    error: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    warning: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    info: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    loading: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+    destroy: () => void;
+}
+/**
+ * Create the a11y-feedback store for Svelte
+ */
+declare function useA11yFeedback(): A11yFeedbackStore;
+
+/**
+ * Simple announce hook for Svelte
+ */
+
+/**
+ * Announce functions interface
+ */
+interface A11yAnnounce {
+    success: (message: string, options?: FeedbackOptions) => Promise<void>;
+    error: (message: string, options?: FeedbackOptions) => Promise<void>;
+    warning: (message: string, options?: FeedbackOptions) => Promise<void>;
+    info: (message: string, options?: FeedbackOptions) => Promise<void>;
+    loading: (message: string, options?: FeedbackOptions) => Promise<void>;
+}
+/**
+ * Create simple announce functions for screen readers
+ */
+declare function useA11yAnnounce(): A11yAnnounce;
+
+/**
+ * Configuration hook for Svelte
+ */
+
+/**
+ * Config store interface
+ */
+interface FeedbackConfigStore extends Readable<FeedbackConfig> {
+    update: (config: Partial<FeedbackConfig>) => void;
+    reset: () => void;
+}
+/**
+ * Create a config store for a11y-feedback
+ */
+declare function useFeedbackConfig(): FeedbackConfigStore;
+
+/**
+ * A11y Feedback store state
+ */
+interface A11yFeedbackState {
+    notifications: readonly FeedbackEvent[];
+    unreadCount: number;
+    config: FeedbackConfig;
+}
+/**
+ * Create a Svelte store for a11y-feedback
+ */
+declare function createA11yFeedbackStore(): {
+    subscribe: (this: void, run: svelte_store.Subscriber<A11yFeedbackState>, invalidate?: svelte_store.Invalidator<A11yFeedbackState> | undefined) => svelte_store.Unsubscriber;
+    /**
+     * Send a notification
+     */
+    notify: (message: string, type: FeedbackType, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send a success notification
+     */
+    success: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send an error notification
+     */
+    error: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send a warning notification
+     */
+    warning: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send an info notification
+     */
+    info: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send a loading notification
+     */
+    loading: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Update configuration
+     */
+    configure: (config: Partial<FeedbackConfig>) => void;
+    /**
+     * Cleanup subscriptions
+     */
+    destroy: () => void;
+};
+
+export { type A11yFeedbackStore, createA11yFeedbackStore, useA11yAnnounce, useA11yFeedback, useFeedbackConfig };

package/dist/index.d.ts

@@ -0,0 +1,114 @@
+import * as svelte_store from 'svelte/store';
+import { Readable } from 'svelte/store';
+import { FeedbackEvent, FeedbackType, FeedbackOptions, FeedbackConfig } from '@theaccessibleteam/a11y-feedback';
+export { ConfirmOptions, FeedbackConfig, FeedbackEvent, FeedbackOptions, FeedbackType, NotificationAction, ProgressController, ProgressOptions, PromptOptions, RichContent } from '@theaccessibleteam/a11y-feedback';
+
+/**
+ * Main hook for a11y-feedback in Svelte
+ */
+
+/**
+ * A11y Feedback store interface
+ */
+interface A11yFeedbackStore extends Readable<{
+    notifications: readonly FeedbackEvent[];
+    unreadCount: number;
+}> {
+    notify: (message: string, type: FeedbackType, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    success: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    error: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    warning: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    info: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    loading: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+    destroy: () => void;
+}
+/**
+ * Create the a11y-feedback store for Svelte
+ */
+declare function useA11yFeedback(): A11yFeedbackStore;
+
+/**
+ * Simple announce hook for Svelte
+ */
+
+/**
+ * Announce functions interface
+ */
+interface A11yAnnounce {
+    success: (message: string, options?: FeedbackOptions) => Promise<void>;
+    error: (message: string, options?: FeedbackOptions) => Promise<void>;
+    warning: (message: string, options?: FeedbackOptions) => Promise<void>;
+    info: (message: string, options?: FeedbackOptions) => Promise<void>;
+    loading: (message: string, options?: FeedbackOptions) => Promise<void>;
+}
+/**
+ * Create simple announce functions for screen readers
+ */
+declare function useA11yAnnounce(): A11yAnnounce;
+
+/**
+ * Configuration hook for Svelte
+ */
+
+/**
+ * Config store interface
+ */
+interface FeedbackConfigStore extends Readable<FeedbackConfig> {
+    update: (config: Partial<FeedbackConfig>) => void;
+    reset: () => void;
+}
+/**
+ * Create a config store for a11y-feedback
+ */
+declare function useFeedbackConfig(): FeedbackConfigStore;
+
+/**
+ * A11y Feedback store state
+ */
+interface A11yFeedbackState {
+    notifications: readonly FeedbackEvent[];
+    unreadCount: number;
+    config: FeedbackConfig;
+}
+/**
+ * Create a Svelte store for a11y-feedback
+ */
+declare function createA11yFeedbackStore(): {
+    subscribe: (this: void, run: svelte_store.Subscriber<A11yFeedbackState>, invalidate?: svelte_store.Invalidator<A11yFeedbackState> | undefined) => svelte_store.Unsubscriber;
+    /**
+     * Send a notification
+     */
+    notify: (message: string, type: FeedbackType, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send a success notification
+     */
+    success: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send an error notification
+     */
+    error: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send a warning notification
+     */
+    warning: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send an info notification
+     */
+    info: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Send a loading notification
+     */
+    loading: (message: string, options?: FeedbackOptions) => Promise<FeedbackEvent>;
+    /**
+     * Update configuration
+     */
+    configure: (config: Partial<FeedbackConfig>) => void;
+    /**
+     * Cleanup subscriptions
+     */
+    destroy: () => void;
+};
+
+export { type A11yFeedbackStore, createA11yFeedbackStore, useA11yAnnounce, useA11yFeedback, useFeedbackConfig };

package/dist/index.js

@@ -0,0 +1,201 @@
+// src/useA11yFeedback.ts
+import { writable } from "svelte/store";
+import {
+  notify,
+  dismissVisualFeedback,
+  dismissAllVisualFeedback,
+  getNotificationHistory,
+  getUnreadCount,
+  onFeedback
+} from "@theaccessibleteam/a11y-feedback";
+function useA11yFeedback() {
+  const state = writable({
+    notifications: getNotificationHistory(),
+    unreadCount: getUnreadCount()
+  });
+  const updateState = () => {
+    state.set({
+      notifications: getNotificationHistory(),
+      unreadCount: getUnreadCount()
+    });
+  };
+  onFeedback("announced", updateState);
+  onFeedback("dismissed", updateState);
+  onFeedback("replaced", updateState);
+  return {
+    subscribe: state.subscribe,
+    notify: async (message, type, options) => {
+      const result = await notify({ message, type, options });
+      updateState();
+      return result;
+    },
+    success: async (message, options) => {
+      const result = await notify.success(message, options);
+      updateState();
+      return result;
+    },
+    error: async (message, options) => {
+      const result = await notify.error(message, options);
+      updateState();
+      return result;
+    },
+    warning: async (message, options) => {
+      const result = await notify.warning(message, options);
+      updateState();
+      return result;
+    },
+    info: async (message, options) => {
+      const result = await notify.info(message, options);
+      updateState();
+      return result;
+    },
+    loading: async (message, options) => {
+      const result = await notify.loading(message, options);
+      updateState();
+      return result;
+    },
+    dismiss: (id) => {
+      dismissVisualFeedback(id);
+      updateState();
+    },
+    dismissAll: () => {
+      dismissAllVisualFeedback();
+      updateState();
+    },
+    destroy: () => {
+    }
+  };
+}
+
+// src/useA11yAnnounce.ts
+import {
+  notify as notify2
+} from "@theaccessibleteam/a11y-feedback";
+function useA11yAnnounce() {
+  return {
+    success: async (message, options) => {
+      await notify2.success(message, options);
+    },
+    error: async (message, options) => {
+      await notify2.error(message, options);
+    },
+    warning: async (message, options) => {
+      await notify2.warning(message, options);
+    },
+    info: async (message, options) => {
+      await notify2.info(message, options);
+    },
+    loading: async (message, options) => {
+      await notify2.loading(message, options);
+    }
+  };
+}
+
+// src/useFeedbackConfig.ts
+import { writable as writable2 } from "svelte/store";
+import {
+  configureFeedback,
+  getConfig,
+  resetConfig
+} from "@theaccessibleteam/a11y-feedback";
+function useFeedbackConfig() {
+  const store = writable2(getConfig());
+  return {
+    subscribe: store.subscribe,
+    update: (config) => {
+      configureFeedback(config);
+      store.set(getConfig());
+    },
+    reset: () => {
+      resetConfig();
+      store.set(getConfig());
+    }
+  };
+}
+
+// src/store.ts
+import { writable as writable3 } from "svelte/store";
+import {
+  notify as notify3,
+  configureFeedback as configureFeedback2,
+  getConfig as getConfig2,
+  getNotificationHistory as getNotificationHistory2,
+  getUnreadCount as getUnreadCount2,
+  onFeedback as onFeedback2
+} from "@theaccessibleteam/a11y-feedback";
+function createA11yFeedbackStore() {
+  const { subscribe, set, update } = writable3({
+    notifications: getNotificationHistory2(),
+    unreadCount: getUnreadCount2(),
+    config: getConfig2()
+  });
+  const handleFeedback = () => {
+    update((state) => ({
+      ...state,
+      notifications: getNotificationHistory2(),
+      unreadCount: getUnreadCount2()
+    }));
+  };
+  onFeedback2("announced", handleFeedback);
+  onFeedback2("dismissed", handleFeedback);
+  return {
+    subscribe,
+    /**
+     * Send a notification
+     */
+    notify: async (message, type, options) => {
+      return notify3({ message, type, options });
+    },
+    /**
+     * Send a success notification
+     */
+    success: async (message, options) => {
+      return notify3.success(message, options);
+    },
+    /**
+     * Send an error notification
+     */
+    error: async (message, options) => {
+      return notify3.error(message, options);
+    },
+    /**
+     * Send a warning notification
+     */
+    warning: async (message, options) => {
+      return notify3.warning(message, options);
+    },
+    /**
+     * Send an info notification
+     */
+    info: async (message, options) => {
+      return notify3.info(message, options);
+    },
+    /**
+     * Send a loading notification
+     */
+    loading: async (message, options) => {
+      return notify3.loading(message, options);
+    },
+    /**
+     * Update configuration
+     */
+    configure: (config) => {
+      configureFeedback2(config);
+      update((state) => ({
+        ...state,
+        config: getConfig2()
+      }));
+    },
+    /**
+     * Cleanup subscriptions
+     */
+    destroy: () => {
+    }
+  };
+}
+export {
+  createA11yFeedbackStore,
+  useA11yAnnounce,
+  useA11yFeedback,
+  useFeedbackConfig
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@theaccessibleteam/a11y-feedback-svelte",
+  "version": "2.0.0",
+  "description": "Svelte bindings for a11y-feedback accessibility notification library",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
+  },
+  "peerDependencies": {
+    "@theaccessibleteam/a11y-feedback": "^2.0.0",
+    "svelte": ">=3.0.0 || >=4.0.0 || >=5.0.0"
+  },
+  "devDependencies": {
+    "svelte": "^4.2.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "svelte",
+    "a11y",
+    "accessibility",
+    "notifications",
+    "screen-reader",
+    "aria"
+  ],
+  "author": "The Accessible Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WOLFIEEEE/a11y-feedback.git",
+    "directory": "packages/svelte"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}