@potok-web-framework/core 0.7.0 → 0.9.0

package/dist/register-component-B92kGFqC.mjs

@@ -0,0 +1,67 @@
+import { c as untrack, i as createSignal, l as LibBlock, r as createEffect } from "./lib-node-DyXPvvVQ.mjs";
+import { i as mergeContext, t as normalizeChildren } from "./normalize-children-BWrn16R7.mjs";
+import { a as Lifecycle, n as HMR_COMPONENTS_REGISTRY, o as LibContextReader, t as getComponentInstanceId } from "./get-component-instance-id-CP6LDtpX.mjs";
+import { t as fragment } from "./fragment-CXNEPBWB.mjs";
+var ShowClass = class extends LibBlock {
+	constructor(t, n) {
+		super(), this.props = t, this.context = n;
+		let o = normalizeChildren(t.children), s = !1;
+		this.addEffect(createEffect(() => {
+			let r = t.when;
+			if (r) {
+				if (s) return;
+				untrack(() => {
+					o.forEach((e, t) => {
+						this.children.push(e(mergeContext(n, {
+							parentBlock: this,
+							index: t
+						})));
+					});
+				});
+			} else this.unmountChildren();
+			s = r;
+		}, !0));
+	}
+};
+function Show(e) {
+	return function(t) {
+		return new ShowClass(e, t);
+	};
+}
+function registerComponent(e, n, r) {
+	let i = HMR_COMPONENTS_REGISTRY.addComponent(n, r, e);
+	HMR_COMPONENTS_REGISTRY.notifyComponentUpdate(n, r);
+	function a(e, t, n = !1) {
+		let r = getComponentInstanceId(t), a = i.getCachedInstance(r);
+		if (!n && a) return a.element;
+		let o = i.component(e);
+		return i.addCachedInstance(r, o), o;
+	}
+	return (e) => LibContextReader({ children(c) {
+		let l = createSignal({ element: a(e, c) }), u = getComponentInstanceId(c);
+		return Lifecycle({
+			onMounted() {
+				let t = HMR_COMPONENTS_REGISTRY.subscribeToComponent(n, r, () => {
+					l.element = null, l.element = a(e, c, !0);
+				});
+				return i.unmarkInstanceAsRemovable(u), () => {
+					t(), i.markInstanceAsRemovable(u), setTimeout(() => {
+						i.getCachedInstance(u)?.isRemovable && i.removeCachedInstance(u);
+					});
+				};
+			},
+			children: [Show({
+				get when() {
+					return l.element !== null;
+				},
+				children: [fragment({ get children() {
+					return [l.element];
+				} })]
+			})]
+		});
+	} });
+}
+function isRegisteredComponentElement(e) {
+	return typeof e == "function" && "dependencies" in e;
+}
+export { registerComponent as n, Show as r, isRegisteredComponentElement as t };

package/dist/serialization-qOayQbjE.mjs

@@ -0,0 +1,108 @@
+import { t as isPureObject } from "./is-pure-object-s_MkQp1w.mjs";
+var SERIALIZERS = {
+	Date: (e) => ({
+		$$type: "Date",
+		value: e.toISOString()
+	}),
+	BigInt: (e) => ({
+		$$type: "BigInt",
+		value: e.toString()
+	}),
+	RegExp: (e) => ({
+		$$type: "RegExp",
+		value: {
+			source: e.source,
+			flags: e.flags
+		}
+	}),
+	Error: (e) => ({
+		$$type: "Error",
+		value: {
+			name: e.name,
+			message: e.message,
+			stack: e.stack
+		}
+	}),
+	URL: (e) => ({
+		$$type: "URL",
+		value: e.href
+	}),
+	Set: (e, t) => ({
+		$$type: "Set",
+		value: Array.from(e, (e) => serializeValue(e, t))
+	}),
+	Map: (e, t) => ({
+		$$type: "Map",
+		value: Array.from(e, ([e, n]) => [serializeValue(e, t), serializeValue(n, t)])
+	}),
+	AbortController: () => ({
+		$$type: "AbortController",
+		value: null
+	})
+}, DESERIALIZERS = {
+	Date: (e) => new Date(e),
+	BigInt: (e) => BigInt(e),
+	RegExp: (e) => new RegExp(e.source, e.flags),
+	Error: (e) => {
+		let t = Error(e.message);
+		return t.name = e.name, t.stack = e.stack, t;
+	},
+	URL: (e) => new URL(e),
+	Set: (e) => new Set(e.map(deserializeValue)),
+	Map: (e) => new Map(e.map(([e, t]) => [deserializeValue(e), deserializeValue(t)])),
+	AbortController: () => new AbortController()
+};
+function getSerializer(e) {
+	if (e instanceof Date) return SERIALIZERS.Date;
+	if (typeof e == "bigint") return SERIALIZERS.BigInt;
+	if (e instanceof RegExp) return SERIALIZERS.RegExp;
+	if (e instanceof Error) return SERIALIZERS.Error;
+	if (e instanceof URL) return SERIALIZERS.URL;
+	if (e instanceof Set) return SERIALIZERS.Set;
+	if (e instanceof Map) return SERIALIZERS.Map;
+	if (e instanceof AbortController) return SERIALIZERS.AbortController;
+}
+function isSerializedValue(e) {
+	return typeof e == "object" && !!e && "$$type" in e && "value" in e;
+}
+function serializeValue(t, n = /* @__PURE__ */ new WeakMap()) {
+	if (n.has(t)) return n.get(t);
+	if (typeof t != "object" || !t) return t;
+	let i = getSerializer(t);
+	if (i) {
+		let e = i(t, n);
+		return n.set(t, e), e;
+	} else if (Array.isArray(t)) {
+		let e = [];
+		n.set(t, e);
+		for (let r = 0; r < t.length; r++) e[r] = serializeValue(t[r], n);
+		return e;
+	} else if (isPureObject(t)) {
+		let e = {};
+		n.set(t, e);
+		for (let [r, i] of Object.entries(t)) e[r] = serializeValue(i, n);
+		return e;
+	}
+	return t;
+}
+function serializeWithTypes(e) {
+	return JSON.stringify(serializeValue(e));
+}
+function deserializeValue(t) {
+	if (typeof t != "object" || !t) return t;
+	if (isSerializedValue(t)) {
+		let e = DESERIALIZERS[t.$$type];
+		return e ? e(t.value) : t;
+	}
+	if (Array.isArray(t)) return t.map(deserializeValue);
+	if (isPureObject(t)) {
+		let e = {};
+		for (let n in t) Object.prototype.hasOwnProperty.call(t, n) && (e[n] = deserializeValue(t[n]));
+		return e;
+	}
+	return t;
+}
+function deserializeWithTypes(e) {
+	return deserializeValue(JSON.parse(e));
+}
+export { serializeWithTypes as n, deserializeWithTypes as t };

package/dist/{bootstrap-app.d.ts → server/bootstrap-app.d.ts}

@@ -1,8 +1,7 @@
-import { PotokElement } from './types';
-type App = (request: Request) => PotokElement;
+import { MaybePromise } from '../types';
 type BootstrapAppOptions = {
-    app: App;
+    render: (request: Request) => MaybePromise<string>;
     port?: number;
 };
-export declare function bootstrapApp(options: BootstrapAppOptions): void;
+export declare function bootstrapApp(options: BootstrapAppOptions): Promise<void>;
 export {};

package/dist/{render-to-string.d.ts → server/render-to-string.d.ts}

@@ -1,2 +1,2 @@
-import { PotokElement } from './types';
+import { PotokElement } from '../types';
 export declare function renderToString(creator: PotokElement): Promise<string>;

package/dist/server-node.d.ts

@@ -1,4 +1,4 @@
-import { LibNode } from './types';
+import { LibNode } from './lib-node';
 export declare class ServerNode {
     libNode: LibNode;
     parent: ServerNode | null;