@potok-web-framework/core 0.1.0 → 0.3.0

package/dist/show.d.ts

@@ -0,0 +1,6 @@
+import { PotokElement, WithChildren } from './types';
+type ShowProps = WithChildren<{
+    when: boolean;
+}>;
+export declare function Show(props: ShowProps): PotokElement;
+export {};

package/dist/signals.d.ts

@@ -0,0 +1,32 @@
+export type SignalValue = Record<string, unknown> | Array<unknown>;
+export type EffectCallback = () => void;
+export type BatchCallback<Value> = () => Value;
+export type UntrackCallback<Value> = () => Value;
+export type DisposerCallback = () => void;
+export type SubscriptionKey = string | number | symbol;
+export type Signal<Value extends SignalValue> = {
+    value: Value;
+    proxy: Value;
+    subscribers: Set<Effect>;
+    subscribe(effect: Effect, key: SubscriptionKey): void;
+};
+export type Effect = {
+    callback: EffectCallback;
+    subscriptions: Map<Signal<SignalValue>, Map<SubscriptionKey, number>>;
+    version: number;
+    ignoreVersion: boolean;
+    dispose(): void;
+    runCallback(): void;
+};
+export type Disposer = {
+    effects: Set<Effect>;
+    dispose(): void;
+};
+export declare function getSignal<Value extends SignalValue>(value: Value): Signal<Value> | undefined;
+export declare function isSignal<Value extends SignalValue>(value: Value): boolean;
+export declare function createSignal<Value extends SignalValue>(value: Value): Value;
+export declare function createEffect(callback: EffectCallback, disableVersionning?: boolean): Effect;
+export declare function batch<Value>(callback: BatchCallback<Value>): Value;
+export declare function untrack<Value>(callback: UntrackCallback<Value>): Value;
+export declare function deepTrack(value: SignalValue, depth?: number): void;
+export declare function createDisposer(callback: DisposerCallback): Disposer;

package/dist/store.d.ts

@@ -0,0 +1,26 @@
+import { PotokElement, WithChildren } from './types';
+type State = Record<string, any>;
+type StateOptions<P extends StoreProps> = {
+    props: P;
+};
+type Actions = Record<string, (...args: any[]) => any>;
+type ActionsOptions<P extends StoreProps, S extends State> = {
+    props: P;
+    state: S;
+};
+type StoreProps = Record<string, any>;
+type StoreInitiator<P extends StoreProps, S extends State, A extends Actions> = {
+    state: (options: StateOptions<P>) => S;
+    actions: (options: ActionsOptions<P, S>) => A;
+};
+export type Store<P extends StoreProps, S extends State, A extends Actions> = {
+    provider(props: WithChildren<P>): PotokElement;
+    reader(props: {
+        children: (options: {
+            state: S;
+            actions: A;
+        }) => PotokElement;
+    }): PotokElement;
+};
+export declare function createStore<P extends StoreProps>(): <S extends State, A extends Actions>(initiator: StoreInitiator<P, S, A>) => Store<P, S, A>;
+export {};

package/dist/text.d.ts

@@ -0,0 +1,5 @@
+import { PotokElement } from './types';
+export type LibTextProps = {
+    text: unknown;
+};
+export declare function text(props: LibTextProps): PotokElement;

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+import { LibBlock } from './block';
+import { LibHTMLElementProps } from './html-element';
+import { LibHTMLElementEventMap, LibHTMLElementTagNameMap } from './prop-types';
+import { LibTextProps } from './text';
+export type LibProps = Record<string, any>;
+export type LibTextNode = {
+    type: 'text';
+    context: LibContext;
+    props: LibTextProps;
+};
+export type LibHtmlElementNode<Tag extends keyof LibHTMLElementTagNameMap = keyof LibHTMLElementTagNameMap> = {
+    type: 'html-element';
+    context: LibContext;
+    props: LibHTMLElementProps<Tag>;
+};
+export type LibNode = LibTextNode | LibHtmlElementNode;
+export type LibContext = {
+    parentBlock: LibBlock | null;
+    index: number;
+    insertNode(parent: LibHtmlElementNode | null, node: LibNode, after: LibNode | null): void;
+    updateTextNode(node: LibTextNode): void;
+    updateHtmlElementNodeProp(node: LibHtmlElementNode, key: string, value: unknown): void;
+    removeNode(node: LibNode): void;
+    portals: Record<string, WithChildren<{}>['children']>;
+    contexts: Record<symbol, Record<string, unknown>>;
+    listeners: Record<keyof LibHTMLElementEventMap, Map<HTMLElement, LibHTMLElementEventMap[keyof LibHTMLElementEventMap]>>;
+    isServer: boolean;
+    promises: Promise<unknown>[];
+    isHydrating: boolean;
+};
+export type PotokElement = (context: LibContext) => LibBlock;
+export type MaybeArray<T> = T | T[];
+export type Child = PotokElement | Child[] | string | number | null | undefined;
+export type Children = MaybeArray<Child> | undefined;
+export type WithChildren<Props extends Record<string, unknown>> = Props & {
+    children?: Children;
+};
+export type ComponentProps = Record<string, unknown>;
+export type Component<Props extends ComponentProps = ComponentProps> = (props: Props) => PotokElement;

package/dist/utils-CAe_kbSH.mjs

@@ -0,0 +1,345 @@
+var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __commonJSMin = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports), __copyProps = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = __getOwnPropNames(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !__hasOwnProp.call(e, d) && d !== o && __defProp(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = __getOwnPropDesc(i, d)) || s.enumerable
+	});
+	return e;
+}, __toESM = (n, r, a) => (a = n == null ? {} : __create(__getProtoOf(n)), __copyProps(r || !n || !n.__esModule ? __defProp(a, "default", {
+	value: n,
+	enumerable: !0
+}) : a, n)), LibBlock = class {
+	node = null;
+	effects = [];
+	children = [];
+	get nearestParentElement() {
+		return this.node ?? this.context.parentBlock?.nearestParentElement ?? null;
+	}
+	get previousBlock() {
+		let e = this.context.parentBlock;
+		return e ? e.children[this.context.index - 1] || (e.node ? null : e.previousBlock) : null;
+	}
+	get nearestPreviousNode() {
+		if (this.node) return this.node;
+		let e = this.children[this.children.length - 1];
+		if (e) return e.nearestPreviousNode;
+		let t = this.previousBlock;
+		return t ? t.nearestPreviousNode : null;
+	}
+	get previousNode() {
+		let e = this.previousBlock;
+		return e ? e.nearestPreviousNode : null;
+	}
+	addEffect(e) {
+		this.effects.push(e);
+	}
+	unmountChildren() {
+		this.children.forEach((e) => {
+			e?.unmount();
+		}), this.children = [];
+	}
+	insertNode() {
+		this.node && this.context.insertNode(this.context.parentBlock?.nearestParentElement ?? null, this.node, this.previousNode);
+	}
+	unmount() {
+		this.node && this.context.removeNode(this.node), this.unmountChildren(), this.effects.forEach((e) => {
+			e.dispose();
+		}), this.effects = [];
+	}
+}, RegisteredComponent = class {
+	component;
+	subscribers;
+	cachedInstances;
+	constructor(e) {
+		this.component = e, this.subscribers = /* @__PURE__ */ new Set(), this.cachedInstances = /* @__PURE__ */ new Map();
+	}
+	getCachedInstance(e) {
+		return this.cachedInstances.get(e);
+	}
+	addCachedInstance(e, t, n) {
+		this.cachedInstances.set(e, {
+			isRemovable: !1,
+			element: t,
+			states: n
+		});
+	}
+	markInstanceAsRemovable(e) {
+		let t = this.cachedInstances.get(e);
+		t && (t.isRemovable = !0);
+	}
+	unmarkInstanceAsRemovable(e) {
+		let t = this.cachedInstances.get(e);
+		t && (t.isRemovable = !1);
+	}
+	removeCachedInstance(e) {
+		this.cachedInstances.delete(e);
+	}
+};
+const HMR_DEV = {
+	registry: new class {
+		components = /* @__PURE__ */ new Map();
+		getModuleComponentsMap(e) {
+			return this.components.has(e) || this.components.set(e, /* @__PURE__ */ new Map()), this.components.get(e);
+		}
+		addComponent(e, t, n) {
+			let r = this.getModuleComponentsMap(e);
+			r.has(t) || r.set(t, new RegisteredComponent(n));
+			let i = r.get(t);
+			return i.component = n, i;
+		}
+		getRegisteredComponent(e, t) {
+			return this.getModuleComponentsMap(e).get(t);
+		}
+		subscribeToComponent(e, t, n) {
+			return this.getRegisteredComponent(e, t)?.subscribers.add(n), () => {
+				this.unsubscribeFromComponent(e, t, n);
+			};
+		}
+		unsubscribeFromComponent(e, t, n) {
+			this.getRegisteredComponent(e, t)?.subscribers.delete(n);
+		}
+		notifyComponentUpdate(e, t) {
+			let n = this.getRegisteredComponent(e, t);
+			if (n) for (let e of n.subscribers) e(n);
+		}
+	}(),
+	currentInstance: null
+};
+function isWindowDefined() {
+	return typeof window < "u";
+}
+function getComponentInstanceId(e) {
+	let t = [], n = e;
+	for (; n;) t.push(n.index), n = n.parentBlock ? n.parentBlock.context : null;
+	return t.reverse().join("_");
+}
+function klona(e) {
+	if (typeof e != "object") return e;
+	var t, n, r = Object.prototype.toString.call(e);
+	if (r === "[object Object]") {
+		if (e.constructor !== Object && typeof e.constructor == "function") for (t in n = new e.constructor(), e) e.hasOwnProperty(t) && n[t] !== e[t] && (n[t] = klona(e[t]));
+		else for (t in n = {}, e) t === "__proto__" ? Object.defineProperty(n, t, {
+			value: klona(e[t]),
+			configurable: !0,
+			enumerable: !0,
+			writable: !0
+		}) : n[t] = klona(e[t]);
+		return n;
+	}
+	if (r === "[object Array]") {
+		for (t = e.length, n = Array(t); t--;) n[t] = klona(e[t]);
+		return n;
+	}
+	return r === "[object Set]" ? (n = /* @__PURE__ */ new Set(), e.forEach(function(e) {
+		n.add(klona(e));
+	}), n) : r === "[object Map]" ? (n = /* @__PURE__ */ new Map(), e.forEach(function(e, t) {
+		n.set(klona(t), klona(e));
+	}), n) : r === "[object Date]" ? /* @__PURE__ */ new Date(+e) : r === "[object RegExp]" ? (n = new RegExp(e.source, e.flags), n.lastIndex = e.lastIndex, n) : r === "[object DataView]" ? new e.constructor(klona(e.buffer)) : r === "[object ArrayBuffer]" ? e.slice(0) : r.slice(-6) === "Array]" ? new e.constructor(e) : e;
+}
+var import_fast_deep_equal = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((e, t) => {
+	t.exports = function e(t, n) {
+		if (t === n) return !0;
+		if (t && n && typeof t == "object" && typeof n == "object") {
+			if (t.constructor !== n.constructor) return !1;
+			var r, i, a;
+			if (Array.isArray(t)) {
+				if (r = t.length, r != n.length) return !1;
+				for (i = r; i-- !== 0;) if (!e(t[i], n[i])) return !1;
+				return !0;
+			}
+			if (t.constructor === RegExp) return t.source === n.source && t.flags === n.flags;
+			if (t.valueOf !== Object.prototype.valueOf) return t.valueOf() === n.valueOf();
+			if (t.toString !== Object.prototype.toString) return t.toString() === n.toString();
+			if (a = Object.keys(t), r = a.length, r !== Object.keys(n).length) return !1;
+			for (i = r; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(n, a[i])) return !1;
+			for (i = r; i-- !== 0;) {
+				var o = a[i];
+				if (!e(t[o], n[o])) return !1;
+			}
+			return !0;
+		}
+		return t !== t && n !== n;
+	};
+})))()), currentEffect = null, currentBatch = null, currentDisposer = null, VALUE_SIGNAL_SYMBOL = Symbol("VALUE_SIGNAL"), ANY_KEY_SYMBOL = Symbol("ANY_KEY");
+function getSignal(e) {
+	return e[VALUE_SIGNAL_SYMBOL];
+}
+function isSignal(e) {
+	return getSignal(e) !== void 0;
+}
+function canBeSignal(e) {
+	return typeof e == "object" && !!e && (Array.isArray(e) || Object.getPrototypeOf(e).isPrototypeOf(Object));
+}
+function createSignal(e) {
+	if (process.env.NODE_ENV === "development" && isWindowDefined()) {
+		let t = HMR_DEV.currentInstance;
+		if (t) if (t.stateIndex < t.states.length) {
+			let n = t.states[t.stateIndex];
+			for (; !(0, import_fast_deep_equal.default)(n?.initial, e) && (t.states.splice(t.stateIndex, 1), n = t.states[t.stateIndex], n););
+			if (n) {
+				let e = getSignal(n.current);
+				if (e) return t.stateIndex++, e.proxy;
+			} else t.states.push({
+				current: e,
+				initial: klona(e)
+			}), t.stateIndex++;
+		} else t.states.push({
+			current: e,
+			initial: klona(e)
+		}), t.stateIndex++;
+	}
+	let t = getSignal(e);
+	if (t) return t.proxy;
+	let n = {
+		value: e,
+		proxy: new Proxy(e, {
+			get(e, t, r) {
+				if (t === VALUE_SIGNAL_SYMBOL) return n;
+				let i = Reflect.get(e, t, r);
+				return currentEffect && n.subscribe(currentEffect, t), canBeSignal(i) ? createSignal(i) : typeof i == "function" ? i.bind(e) : i;
+			},
+			set(e, t, r, i) {
+				let a = Reflect.set(e, t, r, i);
+				return a && n.subscribers.forEach((e) => {
+					let r = e.subscriptions.get(n);
+					(e.ignoreVersion || r?.get(ANY_KEY_SYMBOL) === e.version || r?.get(t) === e.version) && e.runCallback();
+				}), a;
+			}
+		}),
+		subscribers: /* @__PURE__ */ new Set(),
+		subscribe(e, t) {
+			let r = e.subscriptions.get(n);
+			r || (r = /* @__PURE__ */ new Map(), e.subscriptions.set(n, r), n.subscribers.add(e)), r.get(t) !== e.version && r.set(t, e.version);
+		}
+	};
+	return Object.defineProperty(e, VALUE_SIGNAL_SYMBOL, {
+		value: n,
+		enumerable: !1,
+		writable: !1,
+		configurable: !1
+	}), n.proxy;
+}
+function createEffect(e, t = !1) {
+	let n = !1, r = {
+		callback: e,
+		subscriptions: /* @__PURE__ */ new Map(),
+		version: 0,
+		ignoreVersion: t,
+		dispose() {
+			n = !0;
+		},
+		runCallback() {
+			if (n) {
+				r.subscriptions.forEach((e, t) => {
+					t.subscribers.delete(r);
+				}), r.subscriptions.clear();
+				return;
+			}
+			if (currentBatch) {
+				currentBatch.add(r);
+				return;
+			}
+			currentEffect = r, r.version++, e(), currentEffect = null;
+		}
+	};
+	return currentDisposer && currentDisposer.effects.add(r), r.runCallback(), r;
+}
+function batch(e) {
+	if (currentBatch) return e();
+	currentBatch = /* @__PURE__ */ new Set();
+	let t = e(), n = currentBatch;
+	return currentBatch = null, n.forEach((e) => {
+		e.runCallback();
+	}), t;
+}
+function untrack(e) {
+	let t = currentEffect;
+	currentEffect = null;
+	let n = e();
+	return currentEffect = t, n;
+}
+function _deepTrack(e, t, n = 0) {
+	if (t !== void 0 && t <= 0) {
+		console.warn(`depth=${t} не может быть меньше или равен 0`);
+		return;
+	}
+	if (!currentEffect) {
+		console.warn("deepTrack можно использовать только внутри эффекта");
+		return;
+	}
+	let r = currentEffect;
+	untrack(() => {
+		let i = getSignal(e);
+		if (!i) {
+			console.warn("deepTrack можно использовать только с сигналами");
+			return;
+		}
+		if (i.subscribe(r, ANY_KEY_SYMBOL), n++, !(t !== void 0 && n >= t)) if (Array.isArray(e)) for (let i = 0; i < e.length; i++) {
+			let a = e[i];
+			canBeSignal(a) && (currentEffect = r, _deepTrack(a, t, n));
+		}
+		else for (let i in e) {
+			let a = e[i];
+			canBeSignal(a) && (currentEffect = r, _deepTrack(a, t, n));
+		}
+	});
+}
+function deepTrack(e, t) {
+	_deepTrack(e, t);
+}
+var LibText = class extends LibBlock {
+	constructor(e, t) {
+		super(), this.props = e, this.context = t;
+		let n = {
+			type: "text",
+			props: e,
+			context: t
+		};
+		this.node = n, this.addEffect(createEffect(() => {
+			t.updateTextNode(n);
+		}, !0)), this.insertNode();
+	}
+};
+function text(e) {
+	return function(t) {
+		return new LibText(e, t);
+	};
+}
+function mergeContext(e, t) {
+	return {
+		parentBlock: t.parentBlock,
+		get index() {
+			return t.index;
+		},
+		portals: e.portals,
+		contexts: {
+			...e.contexts,
+			...t.contexts
+		},
+		listeners: e.listeners,
+		isServer: e.isServer,
+		promises: e.promises,
+		get isHydrating() {
+			return e.isHydrating;
+		},
+		insertNode: e.insertNode,
+		updateTextNode: e.updateTextNode,
+		updateHtmlElementNodeProp: e.updateHtmlElementNodeProp,
+		removeNode: e.removeNode
+	};
+}
+function objectKeys(e) {
+	return Object.keys(e);
+}
+function extractListenersFromProps(e) {
+	return Object.entries(e).reduce((e, [t, n]) => (t.startsWith("on") && (e[t] = n), e), {});
+}
+function normalizeArray(e) {
+	return Array.isArray(e) ? e : [e];
+}
+function normalizeChild(e) {
+	return typeof e == "string" || typeof e == "number" ? [text({ text: String(e) })] : Array.isArray(e) ? e.flatMap(normalizeChildren) : [e];
+}
+function normalizeChildren(e) {
+	return e ? normalizeArray(e).filter((e) => e != null).flatMap(normalizeChild) : [];
+}
+export { LibBlock as _, objectKeys as a, createEffect as c, getSignal as d, isSignal as f, HMR_DEV as g, isWindowDefined as h, normalizeChildren as i, createSignal as l, getComponentInstanceId as m, mergeContext as n, text as o, untrack as p, normalizeArray as r, batch as s, extractListenersFromProps as t, deepTrack as u };

package/dist/utils.d.ts

@@ -0,0 +1,11 @@
+import { LibHTMLElementEventMap, LibHTMLElementTagNameMap } from './prop-types';
+import { Child, Children, LibContext, MaybeArray, PotokElement } from './types';
+export declare function mergeContext(rootContext: LibContext, childContext: Pick<LibContext, 'parentBlock' | 'index'> & Partial<Pick<LibContext, 'contexts'>>): LibContext;
+export declare function objectKeys<Obj extends Record<string, unknown>>(obj: Obj): (keyof Obj)[];
+export declare function extractListenersFromProps(props: LibHTMLElementTagNameMap[keyof LibHTMLElementTagNameMap]): LibHTMLElementEventMap;
+export declare function map<T extends string | number | symbol, K>(field: T, mapObject: Record<T, K>): K;
+export declare function map<T extends string | number | symbol, K>(field: T | undefined | null, mapObject: Partial<Record<T, K>>, defaultValue: K): K;
+export declare function map<T extends boolean, K>(field: T, mapObject: Record<'true' | 'false', K>): K;
+export declare function normalizeArray<T>(array: MaybeArray<T>): T[];
+export declare function normalizeChild(child: NonNullable<Child>): PotokElement[];
+export declare function normalizeChildren(children: Children): PotokElement[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@potok-web-framework/core",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
@@ -21,9 +21,14 @@
       "import": "./dist/hmr.mjs"
     }
   },
+  "files": [
+    "dist",
+    "package.json"
+  ],
   "scripts": {
     "build": "vite build",
-    "build:watch": "vite build --watch"
+    "build:watch": "vite build --watch",
+    "prepublishOnly": "bun run build"
   },
   "devDependencies": {
     "@types/bun": "catalog:",
@@ -31,7 +36,8 @@
     "fetch-to-node": "^2.1.0",
     "klona": "^2.0.6",
     "vite": "catalog:",
-    "vite-plugin-dts": "catalog:"
+    "vite-plugin-dts": "catalog:",
+    "@potok-web-framework/vite-plugin": "workspace:*"
   },
   "peerDependencies": {
     "typescript": "catalog:"

package/CHANGELOG.md

@@ -1,7 +0,0 @@
-# @potok-web-framework/core
-
-## 0.1.0
-
-### Minor Changes
-
-- 1bd95c1: Релиз фреймворка

package/bun.lock

@@ -1,25 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "web-framework",
-      "devDependencies": {
-        "@types/bun": "latest",
-      },
-      "peerDependencies": {
-        "typescript": "^5",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.2.17", "", { "dependencies": { "bun-types": "1.2.17" } }, "sha512-l/BYs/JYt+cXA/0+wUhulYJB6a6p//GTPiJ7nV+QHa8iiId4HZmnu/3J/SowP5g0rTiERY2kfGKXEK5Ehltx4Q=="],
-
-    "@types/node": ["@types/node@24.0.3", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-R4I/kzCYAdRLzfiCabn9hxWfbuHS573x+r0dJMkkzThEa7pbrcDWK+9zu3e7aBOouf+rQAciqPFMnxwr0aWgKg=="],
-
-    "bun-types": ["bun-types@1.2.17", "", { "dependencies": { "@types/node": "*" } }, "sha512-ElC7ItwT3SCQwYZDYoAH+q6KT4Fxjl8DtZ6qDulUFBmXA8YB4xo+l54J9ZJN+k2pphfn9vk7kfubeSd5QfTVJQ=="],
-
-    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
-
-    "undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
-  }
-}

package/src/block.ts

@@ -1,102 +0,0 @@
-import type { Effect } from './signals'
-import type { LibContext, LibHtmlElementNode, LibNode, LibProps } from './types'
-
-export abstract class LibBlock {
-  node: LibNode | null = null
-  abstract context: LibContext
-  abstract props: LibProps
-  effects: Effect[] = []
-  children: (LibBlock | null)[] = []
-
-  get nearestParentElement(): LibHtmlElementNode | null {
-    return (
-      (this.node as LibHtmlElementNode) ??
-      this.context.parentBlock?.nearestParentElement ??
-      null
-    )
-  }
-
-  get previousBlock(): LibBlock | null {
-    const parentBlock = this.context.parentBlock
-
-    if (!parentBlock) {
-      return null
-    }
-
-    const previousBlock = parentBlock.children[this.context.index - 1]
-
-    if (previousBlock) {
-      return previousBlock
-    }
-
-    if (!parentBlock.node) {
-      return parentBlock.previousBlock
-    }
-
-    return null
-  }
-
-  get nearestPreviousNode(): LibNode | null {
-    if (this.node) {
-      return this.node
-    }
-
-    const lastChild = this.children[this.children.length - 1]
-    if (lastChild) {
-      return lastChild.nearestPreviousNode
-    }
-
-    const previousBlock = this.previousBlock
-    if (previousBlock) {
-      return previousBlock.nearestPreviousNode
-    }
-
-    return null
-  }
-
-  get previousNode(): LibNode | null {
-    const previousBlock = this.previousBlock
-
-    if (previousBlock) {
-      return previousBlock.nearestPreviousNode
-    }
-
-    return null
-  }
-
-  addEffect(effect: Effect) {
-    this.effects.push(effect)
-  }
-
-  unmountChildren() {
-    this.children.forEach((childBlock) => {
-      childBlock?.unmount()
-    })
-    this.children = []
-  }
-
-  insertNode() {
-    if (!this.node) {
-      return
-    }
-
-    this.context.insertNode(
-      this.context.parentBlock?.nearestParentElement ?? null,
-      this.node,
-      this.previousNode,
-    )
-  }
-
-  unmount() {
-    if (this.node) {
-      this.context.removeNode(this.node)
-    }
-
-    this.unmountChildren()
-
-    this.effects.forEach((effect) => {
-      effect.dispose()
-    })
-    this.effects = []
-  }
-}