@lejdar/webdev 0.0.1

package/dist/brain/brain-context.js

@@ -0,0 +1,14 @@
+var o = Object.defineProperty;
+var r = (n, t, a) => t in n ? o(n, t, { enumerable: !0, configurable: !0, writable: !0, value: a }) : n[t] = a;
+var e = (n, t, a) => r(n, typeof t != "symbol" ? t + "" : t, a);
+class c {
+  constructor() {
+    // @ts-ignore
+    e(this, "context");
+    // @ts-ignore
+    e(this, "brain");
+  }
+}
+export {
+  c as BrainContext
+};

package/dist/brain/brain-developer.js

@@ -0,0 +1,13 @@
+import { patch as f } from "../util/paths.js";
+function a() {
+  function n(t, r, o) {
+    return function(c) {
+      const e = (o ?? ((p) => p))(c ?? {}), i = new t(e), u = new r(e);
+      return f(i, u);
+    };
+  }
+  return n;
+}
+export {
+  a as BrainDeveloper
+};

package/dist/brain/brain-implementor.js

@@ -0,0 +1,20 @@
+import { values as a } from "../primitives/object.js";
+import { flatten as l } from "../util/paths.js";
+import { BrainContext as u } from "./brain-context.js";
+function I() {
+  function r(e, m) {
+    function i(o) {
+      const c = (m ?? ((t) => t))(o ?? {}), n = e(o ?? {}), f = l(n);
+      return a(f).filter(
+        (t) => t instanceof u
+      ).forEach((t) => {
+        t.brain = n, t.context = c;
+      }), n;
+    }
+    return i;
+  }
+  return r;
+}
+export {
+  I as BrainImplementor
+};

package/dist/brain/brain.js

@@ -0,0 +1,8 @@
+import { BrainContext as o } from "./brain-context.js";
+import { BrainImplementor as m } from "./brain-implementor.js";
+import { BrainDeveloper as p } from "./brain-developer.js";
+export {
+  o as BrainContext,
+  p as BrainDeveloper,
+  m as BrainImplementor
+};

package/dist/index.js

@@ -0,0 +1,66 @@
+import { default as o, defineComponents as t, defineStyle as s } from "./react/classNames.js";
+import { default as m } from "./react/context.js";
+import { useAsync as a, useAsyncCallback as n, useDebounce as u, usePrevious as x } from "./react/hooks.js";
+import { arraify as i, generate as c, groupBy as d, haveEqualItems as g } from "./primitives/array.js";
+import { construct as b, entries as v, fromEntries as C, isPOJO as O, keys as A, values as B } from "./primitives/object.js";
+import { Result as h } from "./interface/result.js";
+import { useAction as S } from "./interface/operations.js";
+import { useOptionalResult as D, useResult as E } from "./interface/use-result.js";
+import { curry as q } from "./util/curry.js";
+import { memo as J } from "./util/memo.js";
+import { flatten as w, get as z, leafs as F, patch as H, paths as K, unflatten as L } from "./util/paths.js";
+import { Range as N } from "./util/range.js";
+import { Guardian as T } from "./util/guardian.js";
+import { uuid as V } from "uuidv4";
+import { BrainContext as X } from "./brain/brain-context.js";
+import { BrainImplementor as Z } from "./brain/brain-implementor.js";
+import { BrainDeveloper as $ } from "./brain/brain-developer.js";
+import { Aggregate as re } from "./reactive/aggregate.js";
+import { Collection as te } from "./reactive/collection.js";
+import { Store as fe } from "./reactive/store.js";
+import { useCollection as pe, useItem as ae, useObservable as ne, useSuspendedObservable as ue } from "./reactive/reactive-hooks.js";
+export {
+  re as Aggregate,
+  X as BrainContext,
+  $ as BrainDeveloper,
+  Z as BrainImplementor,
+  te as Collection,
+  T as Guardian,
+  N as Range,
+  h as Result,
+  fe as Store,
+  i as arraify,
+  o as cn,
+  b as construct,
+  m as createContext,
+  q as curry,
+  t as defineComponents,
+  s as defineStyle,
+  v as entries,
+  w as flatten,
+  C as fromEntries,
+  c as generate,
+  z as get,
+  d as groupBy,
+  g as haveEqualItems,
+  O as isPOJO,
+  A as keys,
+  F as leafs,
+  J as memo,
+  H as patch,
+  K as paths,
+  L as unflatten,
+  S as useAction,
+  a as useAsync,
+  n as useAsyncCallback,
+  pe as useCollection,
+  u as useDebounce,
+  ae as useItem,
+  ne as useObservable,
+  D as useOptionalResult,
+  x as usePrevious,
+  E as useResult,
+  ue as useSuspendedObservable,
+  V as uuid,
+  B as values
+};

package/dist/interface/interface.js

@@ -0,0 +1,9 @@
+import { Result as t } from "./result.js";
+import { useAction as s } from "./operations.js";
+import { useOptionalResult as l, useResult as p } from "./use-result.js";
+export {
+  t as Result,
+  s as useAction,
+  l as useOptionalResult,
+  p as useResult
+};

package/dist/interface/operations.js

@@ -0,0 +1,17 @@
+import { useState as l, useCallback as c } from "react";
+import { Result as m } from "./result.js";
+import { useOptionalResult as f } from "./use-result.js";
+function g(t, o) {
+  const [r, { reset: n, set: a }] = f(), [u, e] = l(!1);
+  return [c(
+    async (...i) => {
+      e(!0);
+      const s = await t(...i).then(m.backlink);
+      return a(s), e(!1), s;
+    },
+    [t, ...o]
+  ), r, { reset: n, isLoading: u }];
+}
+export {
+  g as useAction
+};

package/dist/interface/result.js

@@ -0,0 +1,34 @@
+import "react";
+var t;
+((r) => {
+  r.ok = (e) => ({
+    ok: !0,
+    data: e,
+    serialized: {
+      ok: !0,
+      data: e
+    },
+    get result() {
+      return this;
+    }
+  }), r.fail = (e) => ({
+    ok: !1,
+    error: e,
+    serialized: {
+      ok: !1,
+      error: e
+    },
+    get result() {
+      return this;
+    }
+  }), r.backlink = (e) => ({
+    ...e,
+    serialized: e,
+    get result() {
+      return this;
+    }
+  });
+})(t || (t = {}));
+export {
+  t as Result
+};

package/dist/interface/use-result.js

@@ -0,0 +1,23 @@
+import { useState as a, useCallback as o } from "react";
+import { Result as e } from "./result.js";
+function R(c) {
+  const [u, n] = a(
+    c && e.backlink(c)
+  ), s = o((t) => (n(e.backlink(t)), t), []), k = o((t) => s(e.ok(t)), [s]), l = o(
+    (t) => s(e.fail(t)),
+    []
+  );
+  return [u, { set: s, success: k, error: l }];
+}
+function i(c) {
+  const [u, n] = a(
+    c ? e.backlink(c) : void 0
+  ), s = o((r) => (n(e.backlink(r)), r), []), k = o((r) => s(e.ok(r)), [s]), l = o((r) => s(e.fail(r)), [s]), t = o(() => {
+    n(void 0);
+  }, [n]);
+  return [u, { set: s, reset: t, success: k, error: l }];
+}
+export {
+  i as useOptionalResult,
+  R as useResult
+};

package/dist/primitives/array.js

@@ -0,0 +1,29 @@
+function a(r, e) {
+  const n = [];
+  for (let t = 0; t < r; t++)
+    n.push(e(t));
+  return n;
+}
+function f(r, e, n = Object.is) {
+  return r.length !== e.length ? !1 : r.findIndex((t, o) => !n(t, e[o])) === -1;
+}
+function s(r) {
+  return Array.isArray(r) ? r : typeof r == "object" && r && Symbol.iterator in r ? (
+    // @ts-ignore
+    [...r]
+  ) : [r];
+}
+function c(r, e) {
+  const n = /* @__PURE__ */ new Map();
+  for (const t of r) {
+    const o = e(t), u = [...n.get(o) ?? [], t];
+    n.set(o, u);
+  }
+  return [...n.values()];
+}
+export {
+  s as arraify,
+  a as generate,
+  c as groupBy,
+  f as haveEqualItems
+};

package/dist/primitives/object.js

@@ -0,0 +1,26 @@
+function e(t) {
+  return [...Object.keys(t)];
+}
+function n(t) {
+  return [...Object.values(t)];
+}
+function r(t) {
+  return Object.entries(t);
+}
+function u(t) {
+  return Object.fromEntries(t);
+}
+function c(t) {
+  return typeof t == "object" && t !== null && Object.getPrototypeOf(t) === Object.prototype;
+}
+function o(t) {
+  return new t();
+}
+export {
+  o as construct,
+  r as entries,
+  u as fromEntries,
+  c as isPOJO,
+  e as keys,
+  n as values
+};

package/dist/primitives/primitives.js

@@ -0,0 +1,14 @@
+import { arraify as t, generate as o, groupBy as s, haveEqualItems as a } from "./array.js";
+import { construct as i, entries as m, fromEntries as n, isPOJO as u, keys as p, values as y } from "./object.js";
+export {
+  t as arraify,
+  i as construct,
+  m as entries,
+  n as fromEntries,
+  o as generate,
+  s as groupBy,
+  a as haveEqualItems,
+  u as isPOJO,
+  p as keys,
+  y as values
+};

package/dist/react/classNames.js

@@ -0,0 +1,44 @@
+import { twMerge as d } from "tailwind-merge";
+import { entries as p, isPOJO as i } from "../primitives/object.js";
+function u(...r) {
+  let n = r.flat(5).filter((e) => !!e).map((e) => typeof e == "string" ? e : Object.entries(e).filter(([, t]) => t).map(([t]) => t)).flat(1);
+  return d(n);
+}
+function l(r) {
+  return r.reduce((n, e) => e ? [
+    ...n,
+    ...typeof e == "object" ? p(e).filter(([, t]) => t).map(([t]) => t) : [e]
+  ] : n, []);
+}
+function h(r, n = {}) {
+  const e = {}, t = {};
+  return p(n).map(([o, f]) => {
+    for (const s in f)
+      t[o] ?? (t[o] = {}), t[o][s] = u(
+        t[o][s],
+        f[s]
+      );
+  }), p(r).map(([o, f]) => {
+    e[o] = u(e[o], f);
+  }), (...o) => {
+    const f = l(o).map((c) => n[c]).map(p).flat(), s = { ...e };
+    for (const [c, m] of f)
+      s[c] = u(s[c], m);
+    return s;
+  };
+}
+function N(...r) {
+  return (...n) => {
+    const e = [], t = l(n);
+    for (const o of r)
+      i(o) ? t.forEach(
+        (f) => e.push(o[f])
+      ) : e.push(o);
+    return u(...e);
+  };
+}
+export {
+  u as default,
+  h as defineComponents,
+  N as defineStyle
+};

package/dist/react/context.js

@@ -0,0 +1,35 @@
+import n, { createElement as m } from "react";
+import { assert as s } from "../util/assert.js";
+import { Result as c } from "../interface/result.js";
+const r = Symbol("empty-context");
+function f(u) {
+  const { initial: i, debugName: t, mapProps: a = (e) => e } = u, o = n.createContext(
+    i ?? r
+  );
+  return {
+    context: o,
+    useContext() {
+      const e = n.useContext(o);
+      return s(
+        e !== r,
+        `No context Provider found in component tree ${t && `(${t})`}`
+      ), e;
+    },
+    useSafe() {
+      const e = n.useContext(o);
+      return e === r ? c.fail(
+        `No context Provider found in component tree ${t && `(${t})`}`
+      ) : c.ok(e);
+    },
+    Provider(e) {
+      return m(o.Provider, {
+        value: a(e),
+        children: e.children
+      });
+    }
+  };
+}
+export {
+  f as default,
+  r as emptyContext
+};

package/dist/react/hooks.js

@@ -0,0 +1,42 @@
+import { useMemo as a, use as f, useState as l, useCallback as b, useRef as m, useEffect as c } from "react";
+import { Subject as p, debounceTime as d } from "rxjs";
+function g(e, s = [e]) {
+  const t = a(
+    e instanceof Promise ? () => e : e,
+    s
+  );
+  return f(t);
+}
+function x(e, s = [e]) {
+  const [t, n] = l({
+    isIdle: !0,
+    isLoading: !1
+  });
+  return [b(async (...o) => {
+    n({ isLoading: !0, isIdle: !1 });
+    const i = await e(...o);
+    return n({ isLoading: !1, isIdle: !1, result: i }), i;
+  }, s), t];
+}
+const u = Symbol("none");
+function I(e) {
+  const s = m(u);
+  c(() => {
+    s.current = e;
+  }, []);
+  const t = s.current === u ? void 0 : s.current, n = s.current !== u;
+  return [t, n];
+}
+function L(e, s) {
+  const [t, n] = l(e), r = a(() => new p(), []);
+  return c(() => r.next(e), [r, e]), c(() => {
+    const o = r.pipe(d(s)).subscribe(n);
+    return () => o.unsubscribe();
+  }, [r]), t;
+}
+export {
+  g as useAsync,
+  x as useAsyncCallback,
+  L as useDebounce,
+  I as usePrevious
+};

package/dist/react/react.js

@@ -0,0 +1,13 @@
+import { default as s, defineComponents as t, defineStyle as n } from "./classNames.js";
+import { default as u } from "./context.js";
+import { useAsync as f, useAsyncCallback as c, useDebounce as l, usePrevious as d } from "./hooks.js";
+export {
+  s as cn,
+  u as createContext,
+  t as defineComponents,
+  n as defineStyle,
+  f as useAsync,
+  c as useAsyncCallback,
+  l as useDebounce,
+  d as usePrevious
+};

package/dist/reactive/aggregate.js

@@ -0,0 +1,28 @@
+var a = Object.defineProperty;
+var n = (m, e, t) => e in m ? a(m, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : m[e] = t;
+var r = (m, e, t) => n(m, typeof e != "symbol" ? e + "" : e, t);
+import { combineLatest as h, map as u } from "rxjs";
+import { memo as f } from "../util/memo.js";
+import { Collection as g } from "./collection.js";
+class _ extends g {
+  constructor(t, o) {
+    super();
+    // TODO: Weaken - check weakmap functionality
+    r(this, "_cache", /* @__PURE__ */ new WeakMap());
+    r(this, "items");
+    const i = o.map((s) => s.watch());
+    this.items = h(i).pipe(
+      u(
+        (s) => t(...s).map(
+          ({ item: c, dependencies: p }) => this.memo(c, p)
+        )
+      )
+    );
+  }
+  memo(t, o) {
+    return f(t, o, this._cache);
+  }
+}
+export {
+  _ as Aggregate
+};

package/dist/reactive/collection.js

@@ -0,0 +1,38 @@
+var c = Object.defineProperty;
+var f = (i, t, e) => t in i ? c(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var s = (i, t, e) => f(i, typeof t != "symbol" ? t + "" : t, e);
+import { of as p, map as r, distinctUntilChanged as a, tap as d, firstValueFrom as l } from "rxjs";
+class m {
+  static from(t) {
+    return new class extends m {
+      constructor() {
+        super(...arguments);
+        s(this, "items", p(t));
+      }
+    }();
+  }
+  watchOne(t) {
+    return this.items.pipe(
+      r((e) => e.find(t) ?? null),
+      a()
+    );
+  }
+  watch(t) {
+    return this.items.pipe(
+      t ? r((e) => e.filter(t)) : d(),
+      // TODO: Test this behavior
+      a(
+        (e, n) => e.length === n.length && e.every((h, u) => h === n[u])
+      )
+    );
+  }
+  async find(t) {
+    return (await l(this.items)).find(t) ?? null;
+  }
+  async list(t) {
+    return (await l(this.items)).filter(t ?? (() => !0));
+  }
+}
+export {
+  m as Collection
+};

package/dist/reactive/reactive-hooks.js

@@ -0,0 +1,29 @@
+import { ObservableResource as o, useObservableSuspense as c } from "observable-hooks";
+import { useMemo as u, useState as f, useEffect as i } from "react";
+function r(e) {
+  const t = u(
+    () => new o(e),
+    [e]
+  );
+  return c(t);
+}
+function p(e) {
+  const [t, s] = f(null);
+  return i(() => {
+    e.subscribe(s);
+  }, [e]), t;
+}
+function b(e, t, s = []) {
+  const n = u(() => e.watch(t), []);
+  return r(n);
+}
+function d(e, t, s = []) {
+  const n = u(() => e.watchOne(t), []);
+  return r(n);
+}
+export {
+  b as useCollection,
+  d as useItem,
+  p as useObservable,
+  r as useSuspendedObservable
+};

package/dist/reactive/reactive.js

@@ -0,0 +1,13 @@
+import { Aggregate as r } from "./aggregate.js";
+import { Collection as s } from "./collection.js";
+import { Store as m } from "./store.js";
+import { useCollection as u, useItem as b, useObservable as f, useSuspendedObservable as x } from "./reactive-hooks.js";
+export {
+  r as Aggregate,
+  s as Collection,
+  m as Store,
+  u as useCollection,
+  b as useItem,
+  f as useObservable,
+  x as useSuspendedObservable
+};

package/dist/reactive/store.js

@@ -0,0 +1,30 @@
+var o = Object.defineProperty;
+var h = (s, e, t) => e in s ? o(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var a = (s, e, t) => h(s, typeof e != "symbol" ? e + "" : e, t);
+import { BehaviorSubject as m } from "rxjs";
+import { Collection as n } from "./collection.js";
+class c extends n {
+  constructor(t = []) {
+    super();
+    a(this, "items");
+    this.items = new m([]);
+  }
+  get state() {
+    return this.items.value;
+  }
+  set state(t) {
+    this.items.next(t);
+  }
+  add(t) {
+    return this.items.next([...this.items.value, t]), t;
+  }
+  update(t, i) {
+    this.state = this.state.map((r) => t(r) ? i(r) : r);
+  }
+  remove(t) {
+    this.state = this.state.filter((i) => !t(i));
+  }
+}
+export {
+  c as Store
+};

package/dist/util/assert.js

@@ -0,0 +1,6 @@
+function r(t, o) {
+  if (!t) throw o;
+}
+export {
+  r as assert
+};

package/dist/util/curry.js

@@ -0,0 +1,12 @@
+import { generate as o, arraify as r } from "../primitives/array.js";
+function f(n, a, m = []) {
+  if (a ?? (a = o(n.length, (t) => t)), m.length < a.length)
+    return (...t) => f(n, a, [...m, t]);
+  const g = m.map(r), s = a.map(
+    (t, p) => r(t).map((e, l) => [e, g[p][l]])
+  ).flat(1).sort(([t], [p]) => t - p).map(([, t]) => t);
+  return n(...s);
+}
+export {
+  f as curry
+};

package/dist/util/guardian.js

@@ -0,0 +1,18 @@
+function G(d, t) {
+  function v(u, c) {
+    return (...r) => {
+      const e = d(...c), f = ({ ok: a, data: _, result: s }) => (n.data = _ ?? null, a ? u == null ? void 0 : u(...r) : (t != null && t.alwaysRun && (u == null || u(...r)), s));
+      return e instanceof Promise ? e.then(f) : f(e);
+    };
+  }
+  function n(...u) {
+    return (c, r, e) => {
+      e.value = v(e.value, u);
+    };
+  }
+  return n;
+}
+const h = G;
+export {
+  h as Guardian
+};

package/dist/util/memo.js

@@ -0,0 +1,11 @@
+const e = Symbol("value");
+function g(o, r, t) {
+  if (r.length) {
+    const [n, ...s] = r;
+    return t.has(n) || t.set(n, /* @__PURE__ */ new WeakMap()), g(o, s, t.get(n));
+  }
+  return t.has(e) ? t.get(e) : t.set(e, o).get(e);
+}
+export {
+  g as memo
+};

package/dist/util/paths.js

@@ -0,0 +1,51 @@
+import { keys as c, isPOJO as u, construct as l } from "../primitives/object.js";
+function* h(n, s = [], t = "") {
+  for (const e of c(n)) {
+    const o = n[e];
+    yield `${t}${e}`, u(o) && // @ts-ignore
+    !s.some((f) => o instanceof f) && (yield* h(o, s, `${t}${e}.`));
+  }
+}
+function* a(n, s = [], t = "") {
+  for (const e of c(n)) {
+    const o = n[e];
+    u(o) && // @ts-ignore
+    !s.some((f) => o instanceof f) ? yield* a(o, s, `${t}${e}.`) : yield `${t}${e}`;
+  }
+}
+function $(n, s) {
+  let [t, ...e] = Array.isArray(s) ? s : s.split(".");
+  if (!t) return n;
+  for (; e.length; ) {
+    if (t in n)
+      return $(n[t], e);
+    t = `${t}.${e.shift()}`;
+  }
+  return n[t];
+}
+function r(n, s = []) {
+  return l(function() {
+    for (const t of a(n, s))
+      this[t] = $(n, t);
+  });
+}
+function y(n) {
+  return l(function() {
+    const s = r(n);
+    for (const t of c(s)) {
+      const e = t.split("."), o = e.slice(0, -1).reduce((f, i) => f[i] ?? (f[i] = {}), this);
+      o[e.at(-1)] = s[t];
+    }
+  });
+}
+function d(n, s) {
+  return y({ ...r(n), ...r(s) });
+}
+export {
+  r as flatten,
+  $ as get,
+  a as leafs,
+  d as patch,
+  h as paths,
+  y as unflatten
+};

package/dist/util/range.js

@@ -0,0 +1,30 @@
+var c = Object.defineProperty;
+var f = (r, t, o) => t in r ? c(r, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : r[t] = o;
+var n = (r, t, o) => f(r, typeof t != "symbol" ? t + "" : t, o);
+import { generate as m } from "../primitives/array.js";
+class e {
+  constructor(...t) {
+    // @ts-ignore
+    n(this, "from");
+    // @ts-ignore
+    n(this, "to");
+    // @ts-ignore
+    n(this, "range");
+    if (t instanceof e) return t;
+    const [o, s] = t.flat();
+    this.from = o, this.to = s, this.range = m(s - o + 1, (a) => a + o);
+  }
+  [Symbol.iterator]() {
+    return this.range[Symbol.iterator]();
+  }
+  toArray() {
+    return this.range;
+  }
+  contains(t) {
+    const o = t instanceof e ? t.from : t, s = t instanceof e ? t.to : t;
+    return o >= this.from && s <= this.to;
+  }
+}
+export {
+  e as Range
+};

package/dist/util/util.js

@@ -0,0 +1,19 @@
+import { curry as t } from "./curry.js";
+import { memo as f } from "./memo.js";
+import { flatten as m, get as p, leafs as x, patch as n, paths as u, unflatten as l } from "./paths.js";
+import { Range as d } from "./range.js";
+import { Guardian as h } from "./guardian.js";
+import { uuid as s } from "uuidv4";
+export {
+  h as Guardian,
+  d as Range,
+  t as curry,
+  m as flatten,
+  p as get,
+  x as leafs,
+  f as memo,
+  n as patch,
+  u as paths,
+  l as unflatten,
+  s as uuid
+};

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@lejdar/webdev",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist",
+    "index.d.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/react.d.ts",
+      "import": "./dist/react/react.js",
+      "require": "./dist/react/react.js",
+      "default": "./dist/react/react.js"
+    },
+    "./interface": {
+      "types": "./dist/interface/interface.d.ts",
+      "import": "./dist/interface/interface.js",
+      "require": "./dist/interface/interface.js",
+      "default": "./dist/interface/interface.js"
+    },
+    "./util": {
+      "types": "./dist/util/util.d.ts",
+      "import": "./dist/util/util.js",
+      "require": "./dist/util/util.js",
+      "default": "./dist/util/util.js"
+    },
+    "./primitives": {
+      "types": "./dist/primitives/primitives.d.ts",
+      "import": "./dist/primitives/primitives.js",
+      "require": "./dist/primitives/primitives.js",
+      "default": "./dist/primitives/primitives.js"
+    },
+    "./brain": {
+      "types": "./dist/brain/brain.d.ts",
+      "import": "./dist/brain/brain.js",
+      "require": "./dist/brain/brain.js",
+      "default": "./dist/brain/brain.js"
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite builde",
+    "build:watch": "node build.js",
+    "test": "vitest ",
+    "test:ui": "vitest --ui --coverage",
+    "deploy": "pnpm build && pnpm publish"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "@typescript/native-preview": "7.0.0-dev.20250908.1",
+    "@vitest/coverage-v8": "3.1.1",
+    "@vitest/ui": "^3.1.1",
+    "jsdom": "^26.1.0",
+    "react-dom": "^19.1.0",
+    "rxjs": "^7.8.2",
+    "typescript": "~5.7.3",
+    "vite": "^6.1.1",
+    "vitest": "^3.1.1"
+  },
+  "peerDependencies": {
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "rxjs": "^7.8.2"
+  },
+  "dependencies": {
+    "@types/assert": "^1.5.11",
+    "@types/node": "^22.14.1",
+    "assert": "^2.1.0",
+    "observable-hooks": "^4.2.4",
+    "path": "^0.12.7",
+    "react": "^19.1.0",
+    "rollup-plugin-dts": "^6.2.1",
+    "sift": "^17.1.3",
+    "tailwind-merge": "^3.2.0",
+    "uuidv4": "^6.2.13",
+    "vite-plugin-dts": "^4.5.3",
+    "watch": "^1.0.2"
+  }
+}