@civet/events 3.0.1 → 4.0.0

package/dist/EventHandler.d.ts

@@ -7,7 +7,7 @@ import { GenericEventReceiver, InferEvent, InferOptions, InferResource } from '.
  *
  * onEvent can be used to directly access events allowing you to add custom event logic to your components.
  */
-export default function EventHandler<EventReceiverI extends GenericEventReceiver, ResourceI extends InferResource<EventReceiverI> = InferResource<EventReceiverI>, OptionsI extends InferOptions<EventReceiverI> = InferOptions<EventReceiverI>, EventI extends InferEvent<EventReceiverI> = InferEvent<EventReceiverI>>({ eventReceiver, resource, disabled, options, onEvent, onNotify, children, }: {
+export default function EventHandler<EventReceiverI extends GenericEventReceiver, EventI extends InferEvent<EventReceiverI> = InferEvent<EventReceiverI>, ResourceI extends InferResource<EventReceiverI> = InferResource<EventReceiverI>, OptionsI extends InferOptions<EventReceiverI> = InferOptions<EventReceiverI>>({ eventReceiver, resource, disabled, options, onEvent, onNotify, children, }: {
     /** EventReceiver to be used */
     eventReceiver?: EventReceiverI;
     /** ResourceContext to be used */

package/dist/EventReceiver.d.ts

@@ -1,16 +1,16 @@
-import { Constructor, GenericDataProvider, ResourceContextValue } from '@civet/core';
-export default abstract class EventReceiver<Resource extends ResourceContextValue<GenericDataProvider>, Event, Options> {
-    readonly _inferResource: Resource;
+import { Constructor, GenericDataProvider, Notifier, ResourceContextValue } from '@civet/core';
+export default abstract class EventReceiver<Event, Resource extends ResourceContextValue<GenericDataProvider>, Options> {
     readonly _inferEvent: Event;
+    readonly _inferResource: Resource;
     readonly _inferOptions: Options;
-    subscribe<ResourceI extends Resource = Resource, OptionsI extends Options = Options, EventI extends Event = Event>(resource: ResourceI, options: OptionsI | undefined, handler: (events: EventI[]) => void): () => void;
-    abstract handleSubscribe(resource: Resource, options: Options | undefined, handler: (events: Event[]) => void): () => void;
+    subscribe<EventI extends Event = Event, ResourceI extends Resource = Resource, OptionsI extends Options = Options>(resource: Notifier<[ResourceI | undefined]>, options: OptionsI | undefined, handler: (events: EventI[]) => void): () => void;
+    abstract handleSubscribe(resource: Notifier<[Resource | undefined]>, options: Options | undefined, handler: (events: Event[]) => void): () => void;
 }
 export declare const isEventReceiver: (eventReceiver: unknown) => boolean;
 export type EventReceiverImplementation<EventReceiverI extends GenericEventReceiver, ConstructorArgs extends any[]> = Constructor<ConstructorArgs, EventReceiverI & {
     handleSubscribe(resource: InferResource<EventReceiverI>, options: InferOptions<EventReceiverI> | undefined, handler: (events: InferEvent<EventReceiverI>[]) => void): () => void;
 }>;
-export type GenericEventReceiver = EventReceiver<ResourceContextValue<GenericDataProvider>, unknown, unknown>;
-export type InferResource<EventReceiverI extends GenericEventReceiver> = EventReceiverI['_inferResource'];
+export type GenericEventReceiver = EventReceiver<unknown, ResourceContextValue<GenericDataProvider>, unknown>;
 export type InferEvent<EventReceiverI extends GenericEventReceiver> = EventReceiverI['_inferEvent'];
+export type InferResource<EventReceiverI extends GenericEventReceiver> = EventReceiverI['_inferResource'];
 export type InferOptions<EventReceiverI extends GenericEventReceiver> = EventReceiverI['_inferOptions'];

package/dist/eventPlugin.d.ts

@@ -1,6 +1,6 @@
 import { GenericDataProviderImplementation } from '@civet/core';
 import { GenericEventReceiver, InferEvent, InferOptions } from './EventReceiver';
-type EventProps<EventReceiverI extends GenericEventReceiver, OptionsI extends InferOptions<EventReceiverI> = InferOptions<EventReceiverI>, EventI extends InferEvent<EventReceiverI> = InferEvent<EventReceiverI>> = {
+type EventProps<EventReceiverI extends GenericEventReceiver, EventI extends InferEvent<EventReceiverI> = InferEvent<EventReceiverI>, OptionsI extends InferOptions<EventReceiverI> = InferOptions<EventReceiverI>> = {
     events?: {
         /** EventReceiver to be used */
         eventReceiver?: EventReceiverI;

package/dist/main.js

@@ -1,18 +1,18 @@
-import { createContext as j, useContext as q, useMemo as D, useState as y, useEffect as S } from "react";
-import { jsx as b, Fragment as w } from "react/jsx-runtime";
-import { useResourceContext as P, createPlugin as _ } from "@civet/core";
-const l = j({});
+import { createContext as H, useContext as P, useMemo as N, useState as y, useEffect as q } from "react";
+import { jsx as x, Fragment as A } from "react/jsx-runtime";
+import { useResourceContext as M, Notifier as B, createPlugin as I } from "@civet/core";
+const l = H({});
 l.displayName = "Events.ConfigContext";
-const K = l.Consumer, F = () => q(l);
-function L(...o) {
+const V = l.Consumer, k = () => P(l);
+function W(...o) {
   return (...e) => o.reduce(
     (t, r) => t || (typeof r == "function" ? r(...e) : !1),
     !1
   );
 }
-class H {
-  _inferResource;
+class z {
   _inferEvent;
+  _inferResource;
   _inferOptions;
   subscribe(e, t, r) {
     if (typeof r != "function")
@@ -27,20 +27,20 @@ class H {
     ), n;
   }
 }
-const Q = (o) => o instanceof H;
-function T({
+const X = (o) => o instanceof z;
+function Y({
   eventReceiver: o,
   children: e
 }) {
-  const t = D(() => ({ eventReceiver: o }), [o]);
-  return /* @__PURE__ */ b(l.Provider, { value: t, children: e });
+  const t = N(() => ({ eventReceiver: o }), [o]);
+  return /* @__PURE__ */ x(l.Provider, { value: t, children: e });
 }
-function A(o) {
+function G(o) {
   return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
 }
-var g, E;
-function M() {
-  return E || (E = 1, g = function o(e, t) {
+var E, h;
+function J() {
+  return h || (h = 1, E = function o(e, t) {
     if (e === t) return !0;
     if (e && t && typeof e == "object" && typeof t == "object") {
       if (e.constructor !== t.constructor) return !1;
@@ -58,17 +58,17 @@ function M() {
       for (n = r; n-- !== 0; )
         if (!Object.prototype.hasOwnProperty.call(t, s[n])) return !1;
       for (n = r; n-- !== 0; ) {
-        var u = s[n];
-        if (!o(e[u], t[u])) return !1;
+        var c = s[n];
+        if (!o(e[c], t[c])) return !1;
       }
       return !0;
     }
     return e !== e && t !== t;
-  }), g;
+  }), E;
 }
-var B = M();
-const I = /* @__PURE__ */ A(B);
-function C({
+var K = J();
+const L = /* @__PURE__ */ G(K);
+function j({
   eventReceiver: o,
   resource: e,
   disabled: t,
@@ -76,47 +76,70 @@ function C({
   onEvent: n,
   onNotify: s
 }) {
-  const u = F(), a = o || u.eventReceiver, O = P(), f = e || O, [c, h] = y(f);
-  f?.request !== c?.request && h(f);
-  const [p, x] = y(r);
-  I(p, r) || x(r);
-  const m = !!(t || f?.isDisabled);
-  S(() => a == null || m ? void 0 : a.subscribe(
-    c,
-    p,
-    (v) => {
-      if ((v?.length || 0) === 0) return;
-      let i;
-      if (typeof n == "function" ? i = v.filter((d) => !n(d)) : i = v, i.length === 0 || typeof c?.notify != "function")
-        return;
-      const R = c.notify();
-      typeof s == "function" && R.then((d) => s(d, i));
+  const c = k(), a = o || c.eventReceiver, D = M(), u = e === null ? void 0 : e || D, [i, w] = y(
+    u
+  );
+  u?.request !== i?.request && w(u);
+  const [p, S] = y(r);
+  L(p, r) || S(r);
+  const C = !!(t || u?.isDisabled), [
+    [R, b, v] = [],
+    O
+  ] = y();
+  q(() => {
+    if (a == null || C) {
+      O(void 0);
+      return;
     }
-  ), [a, m, c, p, n, s]);
+    const d = new B(), _ = a.subscribe(
+      d,
+      p,
+      (g) => {
+        if ((g?.length || 0) === 0) return;
+        let f;
+        if (typeof n == "function" ? f = g.filter((m) => !n(m)) : f = g, f.length === 0 || typeof i?.notify != "function")
+          return;
+        const F = i.notify();
+        typeof s == "function" && F.then((m) => s(m, f));
+      }
+    );
+    return d.trigger(i), O([
+      i?.request,
+      i?.revision,
+      d
+    ]), _;
+  }, [a, C, i, p, n, s]), q(() => {
+    v == null || u?.request !== R || u?.revision === b || v.trigger(u);
+  }, [
+    v,
+    u,
+    R,
+    b
+  ]);
 }
-function U({
+function Z({
   eventReceiver: o,
   resource: e,
   disabled: t,
   options: r,
   onEvent: n,
   onNotify: s,
-  children: u
+  children: c
 }) {
-  return C({
+  return j({
     eventReceiver: o,
     resource: e,
     disabled: t,
     options: r,
     onEvent: n,
     onNotify: s
-  }), /* @__PURE__ */ b(w, { children: u });
+  }), /* @__PURE__ */ x(A, { children: c });
 }
-const V = _(
+const $ = I(
   (o) => class extends o {
     extend(t) {
       t.context(
-        (r, { events: n = !1 }) => (C(
+        (r, { events: n = !1 }) => (j(
           typeof n == "boolean" ? { disabled: !n, resource: r } : { ...n, resource: r }
         ), r)
       );
@@ -124,13 +147,13 @@ const V = _(
   }
 );
 export {
-  K as ConfigConsumer,
-  T as ConfigProvider,
-  U as EventHandler,
-  H as EventReceiver,
-  L as composeHandlers,
-  V as eventPlugin,
-  Q as isEventReceiver,
-  F as useConfigContext,
-  C as useEventHandler
+  V as ConfigConsumer,
+  Y as ConfigProvider,
+  Z as EventHandler,
+  z as EventReceiver,
+  W as composeHandlers,
+  $ as eventPlugin,
+  X as isEventReceiver,
+  k as useConfigContext,
+  j as useEventHandler
 };

package/dist/useEventHandler.d.ts

@@ -6,11 +6,11 @@ import { GenericEventReceiver, InferEvent, InferOptions, InferResource } from '.
  *
  * onEvent can be used to directly access events allowing you to add custom event logic to your components.
  */
-export default function useEventHandler<EventReceiverI extends GenericEventReceiver, ResourceI extends InferResource<EventReceiverI> = InferResource<EventReceiverI>, OptionsI extends InferOptions<EventReceiverI> = InferOptions<EventReceiverI>, EventI extends InferEvent<EventReceiverI> = InferEvent<EventReceiverI>>({ eventReceiver: eventReceiverProp, resource: resourceProp, disabled, options: optionsProp, onEvent, onNotify, }: {
+export default function useEventHandler<EventReceiverI extends GenericEventReceiver, EventI extends InferEvent<EventReceiverI> = InferEvent<EventReceiverI>, ResourceI extends InferResource<EventReceiverI> = InferResource<EventReceiverI>, OptionsI extends InferOptions<EventReceiverI> = InferOptions<EventReceiverI>>({ eventReceiver: eventReceiverProp, resource: resourceProp, disabled, options: optionsProp, onEvent, onNotify, }: {
     /** EventReceiver to be used */
     eventReceiver?: EventReceiverI;
     /** ResourceContext to be used */
-    resource?: ResourceI;
+    resource?: ResourceI | null;
     /** Disables the event handler */
     disabled?: boolean;
     /** Options for the EventReceiver */

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@civet/events",
-  "version": "3.0.1",
+  "version": "4.0.0",
   "description": "Civet",
   "author": {
     "name": "Aaron Burmeister"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/civet-org/events.git"
+    "url": "git+https://github.com/civet-org/events.git"
   },
   "bugs": {
     "url": "https://github.com/civet-org/events/issues"
@@ -55,7 +55,7 @@
     "react-dom": ">=18.0"
   },
   "devDependencies": {
-    "@civet/core": "^6.0.2",
+    "@civet/core": "^6.1.1",
     "@eslint/js": "^9.35.0",
     "@types/react": "^19.1.12",
     "@types/react-dom": "^19.1.9",