@civet/events 3.0.0 → 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.d.ts

@@ -2,6 +2,7 @@ import { ConfigConsumer, useConfigContext } from './context';
 export { default as composeHandlers } from './composeHandlers';
 export { default as ConfigProvider } from './ConfigProvider';
 export { default as EventHandler } from './EventHandler';
+export { default as eventPlugin } from './eventPlugin';
 export { default as EventReceiver, isEventReceiver } from './EventReceiver';
 export type { EventReceiverImplementation, GenericEventReceiver, InferEvent, InferOptions, InferResource, } from './EventReceiver';
 export { default as useEventHandler } from './useEventHandler';

package/dist/main.js

@@ -1,124 +1,159 @@
-import { createContext as R, useContext as j, useMemo as q, useState as y, useEffect as D } from "react";
-import { jsx as E, Fragment as S } from "react/jsx-runtime";
-import { useResourceContext as w } from "@civet/core";
-const l = R({});
+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 J = l.Consumer, _ = () => j(l);
-function K(...r) {
-  return (...e) => r.reduce(
-    (t, n) => t || (typeof n == "function" ? n(...e) : !1),
+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 F {
-  _inferResource;
+class z {
   _inferEvent;
+  _inferResource;
   _inferOptions;
-  subscribe(e, t, n) {
-    if (typeof n != "function")
+  subscribe(e, t, r) {
+    if (typeof r != "function")
       throw new Error("Handler must be a function");
-    const o = this.handleSubscribe(
+    const n = this.handleSubscribe(
       e,
       t,
-      n
+      r
     );
-    return typeof o != "function" && console.warn(
+    return typeof n != "function" && console.warn(
       "EventReceiver.handleSubscribe should return a callback to cancel the subscription. Ignoring this warning may result in the execution of obsolete handlers and potential memory leaks."
-    ), o;
+    ), n;
   }
 }
-const L = (r) => r instanceof F;
-function Q({
-  eventReceiver: r,
+const X = (o) => o instanceof z;
+function Y({
+  eventReceiver: o,
   children: e
 }) {
-  const t = q(() => ({ eventReceiver: r }), [r]);
-  return /* @__PURE__ */ E(l.Provider, { value: t, children: e });
+  const t = N(() => ({ eventReceiver: o }), [o]);
+  return /* @__PURE__ */ x(l.Provider, { value: t, children: e });
 }
-function H(r) {
-  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+function G(o) {
+  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
 }
-var g, C;
-function A() {
-  return C || (C = 1, g = function r(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;
-      var n, o, s;
+      var r, n, s;
       if (Array.isArray(e)) {
-        if (n = e.length, n != t.length) return !1;
-        for (o = n; o-- !== 0; )
-          if (!r(e[o], t[o])) return !1;
+        if (r = e.length, r != t.length) return !1;
+        for (n = r; n-- !== 0; )
+          if (!o(e[n], t[n])) return !1;
         return !0;
       }
       if (e.constructor === RegExp) return e.source === t.source && e.flags === t.flags;
       if (e.valueOf !== Object.prototype.valueOf) return e.valueOf() === t.valueOf();
       if (e.toString !== Object.prototype.toString) return e.toString() === t.toString();
-      if (s = Object.keys(e), n = s.length, n !== Object.keys(t).length) return !1;
-      for (o = n; o-- !== 0; )
-        if (!Object.prototype.hasOwnProperty.call(t, s[o])) return !1;
-      for (o = n; o-- !== 0; ) {
-        var u = s[o];
-        if (!r(e[u], t[u])) return !1;
+      if (s = Object.keys(e), r = s.length, r !== Object.keys(t).length) return !1;
+      for (n = r; n-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(t, s[n])) return !1;
+      for (n = r; n-- !== 0; ) {
+        var c = s[n];
+        if (!o(e[c], t[c])) return !1;
       }
       return !0;
     }
     return e !== e && t !== t;
-  }), g;
+  }), E;
 }
-var M = A();
-const P = /* @__PURE__ */ H(M);
-function B({
-  eventReceiver: r,
+var K = J();
+const L = /* @__PURE__ */ G(K);
+function j({
+  eventReceiver: o,
   resource: e,
   disabled: t,
-  options: n,
-  onEvent: o,
+  options: r,
+  onEvent: n,
   onNotify: s
 }) {
-  const u = _(), a = r || u.eventReceiver, b = w(), f = e || b, [c, O] = y(f);
-  f?.request !== c?.request && O(f);
-  const [p, h] = y(n);
-  P(p, n) || h(n);
-  const m = !!(t || f?.isDisabled);
-  D(() => a == null || m ? void 0 : a.subscribe(
-    c,
-    p,
-    (v) => {
-      if ((v?.length || 0) === 0) return;
-      let i;
-      if (typeof o == "function" ? i = v.filter((d) => !o(d)) : i = v, i.length === 0 || typeof c?.notify != "function")
-        return;
-      const x = c.notify();
-      typeof s == "function" && x.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, o, 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 T({
-  eventReceiver: r,
+function Z({
+  eventReceiver: o,
   resource: e,
   disabled: t,
-  options: n,
-  onEvent: o,
+  options: r,
+  onEvent: n,
   onNotify: s,
-  children: u
+  children: c
 }) {
-  return B({
-    eventReceiver: r,
+  return j({
+    eventReceiver: o,
     resource: e,
     disabled: t,
-    options: n,
-    onEvent: o,
+    options: r,
+    onEvent: n,
     onNotify: s
-  }), /* @__PURE__ */ E(S, { children: u });
+  }), /* @__PURE__ */ x(A, { children: c });
 }
+const $ = I(
+  (o) => class extends o {
+    extend(t) {
+      t.context(
+        (r, { events: n = !1 }) => (j(
+          typeof n == "boolean" ? { disabled: !n, resource: r } : { ...n, resource: r }
+        ), r)
+      );
+    }
+  }
+);
 export {
-  J as ConfigConsumer,
-  Q as ConfigProvider,
-  T as EventHandler,
-  F as EventReceiver,
-  K as composeHandlers,
-  L as isEventReceiver,
-  _ as useConfigContext,
-  B 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.0",
+  "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",