ddd-react 1.0.0

package/README.md

@@ -0,0 +1 @@
+# react-new

package/dist/attributes.d.ts

@@ -0,0 +1,6 @@
+import type { ElementAttributes } from './types';
+export declare function setStyle(el: HTMLElement, name: string, value: string | number): void;
+export declare function removeStyle(el: HTMLElement, name: string): void;
+export declare function setAttributes(el: HTMLElement, attrs: ElementAttributes): void;
+export declare function setAttribute(el: HTMLElement, name: string, value: unknown): void;
+export declare function removeAttribute(el: HTMLElement, name: string): void;

package/dist/component.d.ts

@@ -0,0 +1,37 @@
+import type { ComponentState, VDOMNode, WithChildrenProps } from './types';
+export declare abstract class Component<P = {}, S = ComponentState, ContextValueType = null> {
+    private isMounted;
+    vdom: VDOMNode | null;
+    private hostEl;
+    parent: Component | null;
+    props: P & WithChildrenProps;
+    state: S;
+    context: ContextValueType;
+    dependencies: {
+        consumer: Component;
+    }[];
+    subscribedProvider: Component | null;
+    constructor(props: P, parentComponent: Component | null);
+    addDependency({ consumer }: {
+        consumer: Component;
+    }): void;
+    removeDependency({ consumer }: {
+        consumer: Component;
+    }): void;
+    notify(): void;
+    onMount(): void | Promise<void>;
+    onUnmount(): void | Promise<void>;
+    onUpdate(): void | Promise<void>;
+    onWillUnmount(): void | Promise<void>;
+    abstract render(): VDOMNode;
+    get elements(): HTMLElement[];
+    get firstElement(): HTMLElement | undefined;
+    get offset(): number;
+    updateProps(props: Partial<P>): void;
+    setState(state: Partial<S> | ((prevState: S, props: P) => Partial<S>)): void;
+    mount(hostEl: HTMLElement, index?: number | null): void;
+    unmount(): void;
+    private patch;
+    private updateContext;
+    private subscribeToProvider;
+}

package/dist/context.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from './types';
+export declare function createContext<T>(defaultValue: T): Context<T>;

package/dist/ddd-react.mjs

@@ -0,0 +1,718 @@
+function v(e, t) {
+  if (e === null || t === null || e === void 0 || t === void 0)
+    return e === t;
+  if (typeof e != typeof t)
+    return !1;
+  if (Object.is(e, t))
+    return !0;
+  if (typeof e == "object") {
+    if (e.constructor !== t.constructor)
+      return !1;
+    if (Array.isArray(e)) {
+      if (e.length !== t.length)
+        return !1;
+      for (let r = 0; r < e.length; ++r)
+        if (!v(e[r], t[r]))
+          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();
+    const n = Object.keys(e);
+    if (n.length !== Object.keys(t).length)
+      return !1;
+    for (let r = 0; r < n.length; ++r)
+      if (!Object.prototype.hasOwnProperty.call(t, n[r]))
+        return !1;
+    for (let r = 0; r < n.length; ++r) {
+      const s = n[r];
+      if (!(s === "_owner" && e.$$typeof) && !v(e[s], t[s]))
+        return !1;
+    }
+    return !0;
+  }
+  return !1;
+}
+function R(e, t, n, r = null) {
+  function s(i) {
+    const o = i;
+    r ? t.call(r, o) : t(o);
+  }
+  return n.addEventListener(e, s), s;
+}
+function F(e = {}, t, n = null) {
+  const r = {};
+  return Object.entries(e).forEach(([s, i]) => {
+    r[s] = R(
+      s,
+      i,
+      t,
+      n
+    );
+  }), r;
+}
+function G(e = {}, t) {
+  Object.entries(e).forEach(([n, r]) => {
+    t.removeEventListener(n, r);
+  });
+}
+const h = {
+  ADD: "add",
+  REMOVE: "remove",
+  MOVE: "move",
+  NOOP: "noop"
+}, c = {
+  TEXT: "text",
+  ELEMENT: "element",
+  FRAGMENT: "fragment",
+  COMPONENT: "component",
+  PORTAL: "portal"
+};
+function d(e) {
+  const { type: t } = e;
+  switch (t) {
+    case c.TEXT: {
+      q(e);
+      break;
+    }
+    case c.ELEMENT: {
+      U(e);
+      break;
+    }
+    case c.FRAGMENT: {
+      $(e);
+      break;
+    }
+    case c.COMPONENT: {
+      e.component?.unmount();
+      break;
+    }
+    case c.PORTAL: {
+      W(e);
+      break;
+    }
+    default:
+      throw new Error(`Can't destroy DOM of type: ${t}`);
+  }
+  delete e.el;
+}
+function q(e) {
+  const { el: t } = e;
+  t && t.remove();
+}
+function U(e) {
+  const { el: t, children: n, listeners: r, props: s } = e;
+  s?.ref && typeof s.ref == "object" && "current" in s.ref && (s.ref.current = null), t && t.remove(), n && n.forEach(d), r && t && (G(r, t), delete e.listeners);
+}
+function $(e) {
+  const { children: t } = e;
+  t && t.forEach(d);
+}
+function W(e) {
+  const { children: t } = e;
+  t && t.forEach(d);
+}
+function N(e) {
+  return e.filter((t) => t != null);
+}
+function X(e, t) {
+  return {
+    added: t.filter((n) => !e.includes(n)),
+    removed: e.filter((n) => !t.includes(n))
+  };
+}
+class _ {
+  #t = [];
+  #e = [];
+  #n;
+  constructor(t, n) {
+    this.#t = [...t], this.#e = t.map((r, s) => s), this.#n = n;
+  }
+  isAddition(t, n) {
+    return this.findIndexFrom(t, n) === -1;
+  }
+  isNoop(t, n) {
+    if (t >= this.length)
+      return !1;
+    const r = this.#t[t], s = n[t];
+    return this.#n(r, s);
+  }
+  isRemoval(t, n) {
+    if (t >= this.length)
+      return !1;
+    const r = this.#t[t];
+    return n.findIndex(
+      (i) => this.#n(r, i)
+    ) === -1;
+  }
+  findIndexFrom(t, n) {
+    for (let r = n; r < this.length; r++)
+      if (this.#n(t, this.#t[r]))
+        return r;
+    return -1;
+  }
+  originalIndexAt(t) {
+    return this.#e[t];
+  }
+  noopItem(t) {
+    return {
+      op: h.NOOP,
+      originalIndex: this.originalIndexAt(t),
+      index: t,
+      item: this.#t[t]
+    };
+  }
+  removeItemsAfter(t) {
+    const n = [];
+    for (; this.length > t; )
+      n.push(this.removeItem(t));
+    return n;
+  }
+  removeItem(t) {
+    const n = {
+      op: h.REMOVE,
+      index: t,
+      item: this.#t[t]
+    };
+    return this.#t.splice(t, 1), this.#e.splice(t, 1), n;
+  }
+  addItem(t, n) {
+    const r = {
+      op: h.ADD,
+      index: n,
+      item: t
+    };
+    return this.#t.splice(n, 0, t), this.#e.splice(n, 0, -1), r;
+  }
+  moveItem(t, n) {
+    const r = this.findIndexFrom(t, n), s = {
+      op: h.MOVE,
+      originalIndex: this.originalIndexAt(r),
+      from: r,
+      index: n,
+      item: this.#t[r]
+    }, [i] = this.#t.splice(r, 1);
+    this.#t.splice(n, 0, i);
+    const [o] = this.#e.splice(r, 1);
+    return this.#e.splice(n, 0, o), s;
+  }
+  get length() {
+    return this.#t.length;
+  }
+}
+function B(e, t, n = (r, s) => r === s) {
+  const r = [], s = new _(e, n);
+  for (let i = 0; i < t.length; i++) {
+    if (s.isRemoval(i, t)) {
+      r.push(s.removeItem(i)), i--;
+      continue;
+    }
+    if (s.isNoop(i, t)) {
+      r.push(s.noopItem(i));
+      continue;
+    }
+    const o = t[i];
+    if (s.isAddition(o, i)) {
+      r.push(s.addItem(o, i));
+      continue;
+    }
+    r.push(s.moveItem(o, i));
+  }
+  return r.push(...s.removeItemsAfter(t.length)), r;
+}
+function mt(e, t = {}, n = []) {
+  const r = typeof e == "string" ? c.ELEMENT : c.COMPONENT;
+  return {
+    tag: e,
+    props: t,
+    type: r,
+    children: T(N(n))
+  };
+}
+function J(e) {
+  return {
+    type: c.TEXT,
+    value: e,
+    props: {}
+  };
+}
+function K(e) {
+  return {
+    type: c.FRAGMENT,
+    children: T(N(e)),
+    props: {}
+  };
+}
+function Y(e, t) {
+  return {
+    type: c.PORTAL,
+    children: T(N(e)),
+    props: {},
+    container: t
+  };
+}
+function T(e) {
+  return e.map((t) => typeof t == "string" ? J(t) : t);
+}
+function g(e) {
+  if (!e.children)
+    return [];
+  const t = [];
+  for (const n of e.children)
+    n.type === c.FRAGMENT ? t.push(...g(n)) : t.push(n);
+  return t;
+}
+function S(e, t, n) {
+  e.style[t] = n.toString();
+}
+function H(e, t) {
+  e.style[t] = null;
+}
+function z(e, t) {
+  const { class: n, style: r, ...s } = t;
+  n && Q(e, n), r && Object.entries(r).forEach(([i, o]) => {
+    S(e, i, o);
+  });
+  for (const [i, o] of Object.entries(s))
+    C(e, i, o);
+}
+function Q(e, t) {
+  if (e instanceof SVGElement) {
+    e.removeAttribute("class"), typeof t == "string" ? e.setAttribute("class", t) : Array.isArray(t) && e.classList.add(...t);
+    return;
+  }
+  e.className = "", typeof t == "string" ? e.className = t : Array.isArray(t) && e.classList.add(...t);
+}
+function C(e, t, n) {
+  n == null ? w(e, t) : e.setAttribute(t, String(n));
+}
+function w(e, t) {
+  e[t] = null, e.removeAttribute(t);
+}
+let b = !1;
+const O = [];
+function y(e) {
+  O.push(e), Z();
+}
+function Z() {
+  b || (b = !0, queueMicrotask(V));
+}
+function V() {
+  for (; O.length > 0; ) {
+    const e = O.shift();
+    let t;
+    try {
+      t = e();
+    } catch (n) {
+      console.error(`[scheduler]: ${n}`);
+      continue;
+    }
+    Promise.resolve(t).then(
+      () => {
+      },
+      (n) => {
+        console.error(`[scheduler]: ${n}`);
+      }
+    );
+  }
+  b = !1;
+}
+function A(e) {
+  const { on: t = {}, ...n } = e.props;
+  return delete n.key, { props: n, events: t };
+}
+function p(e, t, n = null, r = null) {
+  switch (e.type) {
+    case c.TEXT: {
+      tt(e, t, n);
+      break;
+    }
+    case c.ELEMENT: {
+      nt(e, t, n, r);
+      break;
+    }
+    case c.FRAGMENT: {
+      et(e, t, n, r);
+      break;
+    }
+    case c.COMPONENT: {
+      st(e, t, n, r);
+      const s = e.component;
+      s && y(() => s.onMount());
+      break;
+    }
+    case c.PORTAL: {
+      it(e, r);
+      break;
+    }
+    default:
+      throw new Error(`Can't mount DOM of type: ${e.type}`);
+  }
+}
+function tt(e, t, n) {
+  const { value: r } = e, s = document.createTextNode(r);
+  e.el = s, j(s, t, n);
+}
+function et(e, t, n, r) {
+  const { children: s } = e;
+  e.el = t, s?.forEach((i, o) => {
+    p(i, t, n != null ? n + o : null, r);
+  });
+}
+function nt(e, t, n, r) {
+  const { tag: s, children: i } = e, f = s === "svg" || t instanceof SVGElement ? document.createElementNS("http://www.w3.org/2000/svg", s) : document.createElement(s);
+  rt(f, e, r), e.el = f, i?.forEach((l) => {
+    p(l, f, null, r);
+  }), j(f, t, n);
+}
+function rt(e, t, n) {
+  const { props: r, events: s } = A(t);
+  r.ref && typeof r.ref == "object" && "current" in r.ref && (r.ref.current = e, delete r.ref), t.listeners = F(s, e, n), z(e, r);
+}
+function st(e, t, n, r) {
+  const s = e.tag, { props: i } = A(e), o = new s(i, r);
+  o.mount(t, n), e.component = o, e.el = o.firstElement || null;
+}
+function j(e, t, n) {
+  if (n == null) {
+    t.append(e);
+    return;
+  }
+  if (n < 0)
+    throw new Error(`Index must be a positive integer, got ${n}`);
+  const r = t.childNodes;
+  n >= r.length ? t.append(e) : t.insertBefore(e, r[n]);
+}
+function it(e, t) {
+  const { children: n, container: r } = e;
+  n?.forEach((s) => {
+    p(s, r, null, t);
+  });
+}
+function D(e, t) {
+  if (e.type !== t.type)
+    return !1;
+  if (e.type === c.ELEMENT) {
+    const n = e, r = t, {
+      tag: s,
+      props: { key: i }
+    } = n, {
+      tag: o,
+      props: { key: f }
+    } = r;
+    return s === o && i === f;
+  }
+  if (e.type === c.COMPONENT) {
+    const n = e, r = t, { tag: s } = n, { tag: i } = r;
+    return s === i;
+  }
+  if (e.type === c.PORTAL) {
+    const n = e, r = t;
+    return n.container === r.container;
+  }
+  return !0;
+}
+function M(e, t) {
+  const n = Object.keys(e), r = Object.keys(t), s = [], i = [];
+  for (const o of r)
+    o in e ? e[o] !== t[o] && i.push(o) : s.push(o);
+  return {
+    added: s,
+    removed: n.filter((o) => !(o in t)),
+    updated: i
+  };
+}
+function ot(e) {
+  return e !== "";
+}
+function k(e) {
+  return ot(e.trim());
+}
+function P(e, t, n, r = null) {
+  if (!D(e, t)) {
+    const s = ct(n, e.el);
+    return d(e), p(t, n, s, r), t;
+  }
+  switch (t.el = e.el, t.type) {
+    case c.TEXT:
+      return ut(e, t), t;
+    case c.ELEMENT: {
+      ft(e, t, r);
+      break;
+    }
+    case c.COMPONENT: {
+      dt(e, t);
+      break;
+    }
+    case c.PORTAL: {
+      Et(e, t, r);
+      break;
+    }
+  }
+  return x(e, t, r), t;
+}
+function ct(e, t) {
+  if (!t) return null;
+  const n = Array.from(e.childNodes).indexOf(t);
+  return n < 0 ? null : n;
+}
+function ut(e, t) {
+  const n = e.el, { value: r } = e, { value: s } = t;
+  r !== s && n && (n.nodeValue = s);
+}
+function ft(e, t, n) {
+  const r = e.el, {
+    class: s,
+    style: i,
+    on: o,
+    ...f
+  } = e.props ?? {}, {
+    class: l,
+    style: u,
+    on: a,
+    ...E
+  } = t.props ?? {}, { listeners: m } = e;
+  lt(r, f, E), at(r, s, l), ht(
+    r,
+    i,
+    u
+  ), t.listeners = pt(
+    r,
+    m,
+    o ?? {},
+    a ?? {},
+    n
+  );
+}
+function lt(e, t = {}, n = {}) {
+  const r = t.ref, s = n.ref;
+  r !== s && (r && typeof r == "object" && "current" in r && (r.current = null), s && typeof s == "object" && "current" in s && (s.current = e));
+  const i = { ...t }, o = { ...n };
+  delete i.ref, delete o.ref;
+  const { added: f, removed: l, updated: u } = M(i, o);
+  for (const a of l)
+    w(e, a);
+  for (const a of f.concat(u))
+    C(e, a, o[a]);
+}
+function at(e, t, n) {
+  const r = I(t), s = I(n), { added: i, removed: o } = X(r, s);
+  o.length > 0 && e.classList.remove(...o), i.length > 0 && e.classList.add(...i);
+}
+function I(e = "") {
+  return Array.isArray(e) ? e.filter(k) : String(e).split(/(\s+)/).filter(k);
+}
+function ht(e, t = {}, n = {}) {
+  const { added: r, removed: s, updated: i } = M(t, n);
+  for (const o of s)
+    H(e, o);
+  for (const o of r.concat(i))
+    S(e, o, n[o]);
+}
+function pt(e, t = {}, n = {}, r = {}, s = null) {
+  const { removed: i, added: o, updated: f } = M(n, r);
+  for (const u of i.concat(f)) {
+    const a = t?.[u];
+    a && e.removeEventListener(u, a);
+  }
+  const l = {};
+  for (const u of o.concat(f))
+    l[u] = R(
+      u,
+      r[u],
+      e,
+      s
+    );
+  return l;
+}
+function x(e, t, n) {
+  const r = g(e), s = g(t), i = e.el, o = B(r, s, D), f = n?.offset ?? 0;
+  for (const l of o)
+    if (l.op === h.NOOP) {
+      const { originalIndex: u, index: a } = l;
+      P(r[u], s[a], i, n);
+    }
+  for (const l of o)
+    switch (l.op) {
+      case h.MOVE: {
+        const { from: u, index: a } = l, E = r[u].el, m = i.childNodes[a + f];
+        E && (i.insertBefore(E, m), P(r[u], s[a], i, n));
+        break;
+      }
+      case h.REMOVE: {
+        const { item: u } = l;
+        d(u);
+        break;
+      }
+      case h.ADD: {
+        const { index: u, item: a } = l;
+        p(a, i, u + f, n);
+        break;
+      }
+    }
+}
+function dt(e, t) {
+  const { component: n } = e, { props: r } = A(t);
+  n.updateProps(r), t.component = n, t.el = n.firstElement;
+}
+function Et(e, t, n) {
+  if (e.container !== t.container) {
+    d(e), p(t, document.body, null, n);
+    return;
+  }
+  x(e, t, n);
+}
+const yt = (e) => e.constructor.name.includes("Provider"), gt = (e) => e.constructor.name.includes("Consumer");
+class L {
+  constructor(t = {}, n) {
+    this.isMounted = !1, this.vdom = null, this.hostEl = null, this.parent = null, this.state = {}, this.context = null, this.dependencies = [], this.subscribedProvider = null, this.props = t, this.parent = n;
+  }
+  addDependency({ consumer: t }) {
+    this.dependencies.some((n) => n.consumer === t) || (this.dependencies.push({ consumer: t }), t.subscribedProvider = this);
+  }
+  removeDependency({ consumer: t }) {
+    const n = this.dependencies.findIndex((r) => r.consumer === t);
+    n !== -1 && (this.dependencies.splice(n, 1), t.subscribedProvider = null);
+  }
+  notify() {
+    this.dependencies.forEach(({ consumer: t }) => {
+      t.isMounted && t.updateContext() && t.patch();
+    });
+  }
+  onMount() {
+    return Promise.resolve();
+  }
+  onUnmount() {
+    return Promise.resolve();
+  }
+  onUpdate() {
+    return Promise.resolve();
+  }
+  onWillUnmount() {
+    return Promise.resolve();
+  }
+  get elements() {
+    return this.vdom == null ? [] : this.vdom.type === c.FRAGMENT ? g(this.vdom).flatMap((t) => t.type === c.COMPONENT && t.component ? t.component.elements : t.el ? [t.el] : []) : this.vdom.el ? [this.vdom.el] : [];
+  }
+  get firstElement() {
+    return this.elements[0];
+  }
+  get offset() {
+    return this.vdom?.type === c.FRAGMENT && this.hostEl && this.firstElement ? Array.from(this.hostEl.children).indexOf(this.firstElement) : 0;
+  }
+  updateProps(t) {
+    const n = { ...this.props, ...t }, r = this.props;
+    this.props = n;
+    let s = this.updateContext();
+    v(r, n) && !s || (yt(this) && this.notify(), this.patch());
+  }
+  setState(t) {
+    typeof t == "function" ? this.state = {
+      ...this.state,
+      ...t(this.state, this.props)
+    } : this.state = { ...this.state, ...t }, this.patch();
+  }
+  mount(t, n = null) {
+    if (this.isMounted)
+      throw new Error("Component is already mounted");
+    gt(this) && !this.subscribedProvider && this.subscribeToProvider(), this.updateContext(), this.vdom = this.render(), p(this.vdom, t, n, this), this.hostEl = t, this.isMounted = !0;
+  }
+  unmount() {
+    this.isMounted && (y(() => this.onWillUnmount()), this.subscribedProvider && this.subscribedProvider.removeDependency({ consumer: this }), this.dependencies.forEach(({ consumer: t }) => {
+      t.subscribedProvider = null;
+    }), this.dependencies = [], this.vdom && d(this.vdom), y(() => this.onUnmount()), this.vdom = null, this.hostEl = null, this.isMounted = !1);
+  }
+  patch() {
+    if (!this.isMounted || !this.hostEl || !this.vdom)
+      return;
+    const t = this.render();
+    this.vdom = P(this.vdom, t, this.hostEl, this), y(() => this.onUpdate());
+  }
+  updateContext() {
+    const t = Object.getPrototypeOf(this).constructor.contextType;
+    let n = this.parent;
+    if (t != null) {
+      for (; n; ) {
+        if (Object.getPrototypeOf(n).constructor === t.Provider)
+          return this.context = n.props.value, !0;
+        n = n.parent;
+      }
+      n == null && (this.context = t.defaultValue);
+    }
+    return !1;
+  }
+  subscribeToProvider() {
+    const t = Object.getPrototypeOf(this).constructor.contextType;
+    if (!t)
+      return;
+    let n = this.parent;
+    for (; n; ) {
+      if (Object.getPrototypeOf(n).constructor === t.Provider) {
+        n.addDependency({ consumer: this });
+        break;
+      }
+      n = n.parent;
+    }
+  }
+}
+function vt(e) {
+  class t extends L {
+    render() {
+      let i = [];
+      return Array.isArray(this.props.children) ? i = this.props.children : this.props.children ? i = [this.props.children] : i = [], K(i);
+    }
+  }
+  const r = class r extends L {
+    render() {
+      let i = this.props.children;
+      if (Array.isArray(i))
+        if (i.length === 1 && typeof i[0] == "function")
+          i = i[0];
+        else
+          throw new Error(
+            "Consumer: expected single function child, got array"
+          );
+      if (typeof i != "function")
+        throw new Error("Consumer: children is not a function");
+      return i(this.context);
+    }
+  };
+  r.contextType = {
+    Provider: t,
+    defaultValue: e
+  };
+  let n = r;
+  return {
+    Provider: t,
+    Consumer: n,
+    defaultValue: e
+  };
+}
+function bt(e, t) {
+  if (!t)
+    throw new Error("Container element is not provided for rendering.");
+  p(e, t);
+}
+function Ot(e = null) {
+  return {
+    current: e
+  };
+}
+function Pt(e, t) {
+  const n = Array.isArray(e) ? e : [e];
+  return Y(n, t);
+}
+export {
+  L as Component,
+  vt as createContext,
+  Pt as createPortal,
+  Ot as createRef,
+  mt as h,
+  K as hFragment,
+  J as hString,
+  bt as render
+};

package/dist/destroy-dom.d.ts

@@ -0,0 +1,2 @@
+import type { VDOMNode } from './types';
+export declare function destroyDOM(vdom: VDOMNode): void;

package/dist/events.d.ts

@@ -0,0 +1,6 @@
+import type { Component } from './component';
+export type EventHandler<T extends Event = Event> = (event: T) => void;
+export type EventListeners = Record<string, EventHandler>;
+export declare function addEventListener<T extends Event = Event>(eventName: string, handler: EventHandler<T>, el: HTMLElement, hostComponent?: Component | null): EventHandler<T>;
+export declare function addEventListeners(listeners: Record<string, Function>, el: HTMLElement, hostComponent?: Component | null): EventListeners;
+export declare function removeEventListeners(listeners: Record<string, Function>, el: HTMLElement): void;

package/dist/h.d.ts

@@ -0,0 +1,15 @@
+import type { Component } from './component';
+import type { ElementVDOMNode, FragmentVDOMNode, PortalVDOMNode, TextVDOMNode, VDOMNode } from './types';
+export interface ElementProps {
+    [key: string]: unknown;
+    on?: Record<string, Function>;
+    key?: string | number;
+    class?: string | string[];
+    style?: Record<string, string | number>;
+}
+export declare function h(tag: typeof Component, props?: ElementProps, children?: (VDOMNode | string | null | undefined)[]): ElementVDOMNode;
+export declare function h(tag: string, props?: ElementProps, children?: (VDOMNode | string | null | undefined)[]): ElementVDOMNode;
+export declare function hString(str: string): TextVDOMNode;
+export declare function hFragment(vNodes: (VDOMNode | string | null | undefined)[]): FragmentVDOMNode;
+export declare function hPortal(vNodes: (VDOMNode | string | null | undefined)[], container: HTMLElement): PortalVDOMNode;
+export declare function extractChildren(vdom: VDOMNode): VDOMNode[];

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { Component } from './component';
+import { createContext } from './context';
+import { h, hFragment, hString } from './h';
+import { render } from './render';
+import { createRef } from './ref';
+import type { Ref } from './ref';
+import type { ComponentType } from './types/types';
+import { createPortal } from './portal';
+export type { ComponentType, Ref };
+export { Component, createContext, createRef, h, hFragment, hString, render, createPortal };

package/dist/jsx/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+import { Fragment, jsx as jsxDEV } from './jsx-runtime';
+export { Fragment, jsxDEV };

package/dist/jsx/jsx-runtime.d.ts

@@ -0,0 +1,4 @@
+import type { IProp, VDOMNode } from '../types';
+export declare const Fragment: unique symbol;
+export type Child = VDOMNode | string | number | boolean | null | undefined;
+export declare function jsx(tag: unknown, props?: IProp, ...children: Array<Child | Child[]>): VDOMNode;

package/dist/mount-dom.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from './component';
+import type { VDOMNode } from './types';
+export declare function mountDOM(vdom: VDOMNode, parentEl: HTMLElement, index?: number | null, hostComponent?: Component | null): void;

package/dist/nodes-equal.d.ts

@@ -0,0 +1,2 @@
+import type { VDOMNode } from './types';
+export declare function areNodesEqual(nodeOne: VDOMNode, nodeTwo: VDOMNode): boolean;

package/dist/patch-dom.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from './component';
+import type { VDOMNode } from './types';
+export declare function patchDOM(oldVdom: VDOMNode, newVdom: VDOMNode, parentEl: HTMLElement, hostComponent?: Component | null): VDOMNode;

package/dist/portal.d.ts

@@ -0,0 +1,2 @@
+import type { PortalVDOMNode, VDOMNode } from './types/vdom';
+export declare function createPortal(children: VDOMNode | VDOMNode[], container: HTMLElement): PortalVDOMNode;

package/dist/ref.d.ts

@@ -0,0 +1,4 @@
+export interface Ref<T = unknown> {
+    current: T | null;
+}
+export declare function createRef<T = unknown>(initialValue?: T): Ref<T>;

package/dist/render.d.ts

@@ -0,0 +1,2 @@
+import type { VDOMNode } from './types';
+export declare function render(vnode: VDOMNode, container: HTMLElement): void;

package/dist/scheduler.d.ts

@@ -0,0 +1 @@
+export declare function enqueueJob(job: () => unknown | Promise<unknown>): void;

package/dist/types/consts.d.ts

@@ -0,0 +1,13 @@
+export declare const ARRAY_DIFF_OP: {
+    readonly ADD: "add";
+    readonly REMOVE: "remove";
+    readonly MOVE: "move";
+    readonly NOOP: "noop";
+};
+export declare const DOM_TYPES: {
+    readonly TEXT: "text";
+    readonly ELEMENT: "element";
+    readonly FRAGMENT: "fragment";
+    readonly COMPONENT: "component";
+    readonly PORTAL: "portal";
+};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './consts';
+export * from './types';
+export * from './vdom';

package/dist/types/types.d.ts

@@ -0,0 +1,48 @@
+import type { Component } from '../component.ts';
+import type { VDOMNode } from './';
+import { ARRAY_DIFF_OP } from './consts';
+export type EventHandler = (...args: any[]) => void;
+export type IEvent = Record<string, EventHandler>;
+export type IProp = Record<string, unknown>;
+export interface PropsAndEvents {
+    props: IProp;
+    events: IEvent;
+}
+export interface ArrayDiffResult<T> {
+    added: T[];
+    removed: T[];
+}
+export interface ArrayDiffOperation<T> {
+    op: ArrayDiffOp;
+    index: number;
+    item: T;
+    originalIndex?: number;
+    from?: number;
+}
+export type ArrayDiffOp = (typeof ARRAY_DIFF_OP)[keyof typeof ARRAY_DIFF_OP];
+export interface ObjectsDiffResult {
+    added: string[];
+    removed: string[];
+    updated: string[];
+}
+export type PlainObject = Record<string, unknown>;
+export interface StyleObject {
+    [key: string]: string | number;
+}
+export interface ElementAttributes {
+    class?: string | string[];
+    style?: StyleObject;
+    [key: string]: unknown;
+}
+export interface Context<T> {
+    Provider: Function;
+    Consumer: Function;
+    defaultValue: T;
+}
+export interface ComponentState {
+    [key: string]: unknown;
+}
+export interface WithChildrenProps {
+    children?: VDOMNode[] | VDOMNode | string | Function;
+}
+export type ComponentType<Props = any, ComponentState = any, Context = any> = new (props: Props, parentComponent: Component<{}, any, null> | null) => Component<Props, ComponentState, Context>;

package/dist/types/vdom.d.ts

@@ -0,0 +1,51 @@
+import type { Component } from '../component';
+import type { EventListeners } from '../events';
+import { DOM_TYPES } from './consts';
+import type { IEvent, IProp } from './types';
+export type DOMType = (typeof DOM_TYPES)[keyof typeof DOM_TYPES];
+export interface VDOMNode {
+    type: DOMType;
+    props: IProp & {
+        on?: IEvent;
+        key?: string | number;
+    };
+    children?: VDOMNode[];
+    tag?: string | (new (...args: any[]) => Component);
+    value?: string;
+    component?: Component;
+    el?: Node | null;
+    listeners?: EventListeners;
+}
+export interface TextVDOMNode extends VDOMNode {
+    type: typeof DOM_TYPES.TEXT;
+    value: string;
+    el?: Text | null;
+}
+export interface ElementVDOMNode extends VDOMNode {
+    type: typeof DOM_TYPES.ELEMENT;
+    tag: string;
+    children?: VDOMNode[];
+    el?: HTMLElement | null;
+    props: IProp & {
+        on?: IEvent;
+        key?: string | number;
+    };
+    listeners?: EventListeners;
+}
+export interface FragmentVDOMNode extends VDOMNode {
+    type: typeof DOM_TYPES.FRAGMENT;
+    children?: VDOMNode[];
+    el?: HTMLElement | null;
+}
+export interface ComponentVDOMNode extends VDOMNode {
+    type: typeof DOM_TYPES.COMPONENT;
+    tag: new (...args: any[]) => Component;
+    component: Component;
+    el?: HTMLElement | null;
+}
+export interface PortalVDOMNode extends VDOMNode {
+    type: typeof DOM_TYPES.PORTAL;
+    children: VDOMNode[];
+    container: HTMLElement;
+    el?: null;
+}

package/dist/utils/arrays.d.ts

@@ -0,0 +1,19 @@
+import type { ArrayDiffOperation, ArrayDiffResult } from '../types';
+export declare function withoutNulls<T>(arr: (T | null | undefined)[]): T[];
+export declare function arraysDiff<T>(oldArray: T[], newArray: T[]): ArrayDiffResult<T>;
+export declare class ArrayWithOriginalIndices<T> {
+    #private;
+    constructor(array: T[], equalsFn: (a: T, b: T) => boolean);
+    isAddition(item: T, fromIdx: number): boolean;
+    isNoop(index: number, newArray: T[]): boolean;
+    isRemoval(index: number, newArray: T[]): boolean;
+    findIndexFrom(item: T, fromIndex: number): number;
+    originalIndexAt(index: number): number;
+    noopItem(index: number): ArrayDiffOperation<T>;
+    removeItemsAfter(index: number): ArrayDiffOperation<T>[];
+    removeItem(index: number): ArrayDiffOperation<T>;
+    addItem(item: T, index: number): ArrayDiffOperation<T>;
+    moveItem(item: T, toIndex: number): ArrayDiffOperation<T>;
+    get length(): number;
+}
+export declare function arraysDiffSequence<T>(oldArray: T[], newArray: T[], equalsFn?: (a: T, b: T) => boolean): ArrayDiffOperation<T>[];

package/dist/utils/context.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from '../component';
+export declare const isProvider: (component: Component) => boolean;
+export declare const isConsumer: (component: Component) => boolean;

package/dist/utils/objects.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectsDiffResult, PlainObject } from '../types';
+export declare function objectsDiff(oldObj: PlainObject, newObj: PlainObject): ObjectsDiffResult;
+export declare function hasOwnProperty<T extends object>(obj: T, prop: string | number | symbol): prop is keyof T;

package/dist/utils/props.d.ts

@@ -0,0 +1,2 @@
+import type { PropsAndEvents, VDOMNode } from '../types';
+export declare function extractPropsAndEvents(vdom: VDOMNode): PropsAndEvents;

package/dist/utils/strings.d.ts

@@ -0,0 +1,2 @@
+export declare function isNotEmptyString(str: string): boolean;
+export declare function isNotBlankOrEmptyString(str: string): boolean;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "ddd-react",
+  "version": "1.0.0",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "type-check": "tsc --noEmit",
+    "dev": "npm run type-check && rollup -c -w --serve",
+    "build": "tsc && vite build && npm run build:types",
+    "build:types": "tsc -p tsconfig.build.json"
+  },
+  "keywords": [
+    "react",
+    "ddd",
+    "library",
+    "frontend",
+    "typescript"
+  ],
+  "author": "DDD Team",
+  "main": "dist/ddd-react.mjs",
+  "types": "dist/ddd-react.d.ts",
+  "module": "dist/ddd-react.mjs",
+  "license": "ISC",
+  "description": "The minimalistic React-like library made by DDD team v2",
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^16.0.2",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^12.0.2",
+    "@types/node": "^24.8.1",
+    "rollup": "^4.52.4",
+    "rollup-plugin-cleanup": "^3.2.1",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-delete": "^3.0.1",
+    "rollup-plugin-dts": "^6.2.3",
+    "rollup-plugin-filesize": "^10.0.0",
+    "semantic-release": "^24.2.9",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.0"
+  },
+  "dependencies": {
+    "@guanghechen/fast-deep-equal": "^2.3.7"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ]
+}