@finesoft/front 0.5.1 → 0.5.2

package/dist/react-DhwBRw01.d.mts

@@ -0,0 +1,16 @@
+import { f as AppSnapshot, g as WebAppView, h as ViewProps } from "./session-DnB4ZC3x.mjs";
+import { ComponentType, ReactNode } from "react";
+declare namespace react_d_exports {
+  export { NativeView, NativeViews, Outlet, ViewProps, WebAppView, useSnapshot };
+}
+/** Views choose their own page subtype; Outlet supplies the common runtime props. */
+type NativeView = ComponentType<never>;
+type NativeViews = Readonly<Record<string, NativeView>>;
+declare function useSnapshot(app: WebAppView): AppSnapshot;
+declare function Outlet({ app, views }: {
+  readonly app: WebAppView;
+  readonly views: NativeViews;
+}): ReactNode;
+//#endregion
+export { useSnapshot as a, react_d_exports as i, NativeViews as n, Outlet as r, NativeView as t };
+//# sourceMappingURL=react-DhwBRw01.d.mts.map

package/dist/react.d.mts

@@ -0,0 +1,3 @@
+import { g as WebAppView, h as ViewProps } from "./session-DnB4ZC3x.mjs";
+import { a as useSnapshot, n as NativeViews, r as Outlet, t as NativeView } from "./react-DhwBRw01.mjs";
+export { NativeView, NativeViews, Outlet, type ViewProps, type WebAppView, useSnapshot };

package/dist/react.mjs

@@ -0,0 +1,29 @@
+import { createElement, useLayoutEffect, useSyncExternalStore } from "react";
+//#region src/react.ts
+function useSnapshot(app) {
+	return useSyncExternalStore(app.subscribe, () => app.getSnapshot(), () => app.getSnapshot());
+}
+function Outlet({ app, views }) {
+	const snapshot = useSnapshot(app);
+	useLayoutEffect(() => app.commit(snapshot.revision), [app, snapshot.revision]);
+	return createElement("main", { "data-fs-outlet": "" }, snapshot.entries.map((entry) => {
+		const View = views[entry.page.pageType] ?? views["*"];
+		if (!View) throw Error("Missing view: " + entry.page.pageType);
+		return createElement("div", {
+			key: entry.entryId,
+			hidden: !entry.visible,
+			"data-fs-entry": entry.entryId,
+			"data-fs-key": entry.entryId,
+			"data-fs-intent": entry.intent
+		}, createElement(View, {
+			key: entry.entryId + ":" + entry.page.pageType,
+			page: entry.page,
+			app,
+			entry
+		}));
+	}));
+}
+//#endregion
+export { Outlet, useSnapshot };
+
+//# sourceMappingURL=react.mjs.map

package/dist/rolldown-runtime-B4iAMlE-.mjs

@@ -0,0 +1,35 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/dist/secure-fetch-Xlht2jd7.d.mts

@@ -0,0 +1,30 @@
+//#region ../core/src/http/target-guard.d.ts
+/** Host adapter lookup, returning every address used by its resolver. */
+type DnsLookup = (hostname: string) => Promise<readonly string[]>;
+interface TargetGuardOptions {
+  readonly validateDns?: boolean;
+  readonly lookup?: DnsLookup;
+}
+/** Shared target policy for HttpClient and secureFetch. */
+declare function enforceHostGuard(url: string, options?: TargetGuardOptions): Promise<void>;
+//#endregion
+//#region ../core/src/http/secure-fetch.d.ts
+interface SecureFetchOptions {
+  /** Opt out of SSRF defense entirely (default false). */
+  allowInternalHosts?: boolean;
+  /** DNS-resolve hostnames and check each resolved IP (default true). */
+  validateDns?: boolean;
+  /** Required when DNS validation is enabled for a hostname. */
+  lookup?: DnsLookup;
+  /** Host transport enforcing policy at connection time; preserves the injected fetch. */
+  wrapFetch?: (baseFetch: typeof globalThis.fetch) => typeof globalThis.fetch;
+}
+/**
+ * Return a `fetch`-shaped function that refuses requests to private hosts
+ * before each request. DNS preflight alone cannot pin an arbitrary transport;
+ * select a host connection policy when DNS rebinding protection is required.
+ */
+declare function secureFetch(baseFetch: typeof globalThis.fetch, options?: SecureFetchOptions): typeof globalThis.fetch;
+//#endregion
+export { enforceHostGuard as a, TargetGuardOptions as i, secureFetch as n, DnsLookup as r, SecureFetchOptions as t };
+//# sourceMappingURL=secure-fetch-Xlht2jd7.d.mts.map

package/dist/server-controller-proxy-BkVuVWVD.d.mts

@@ -0,0 +1,38 @@
+import { c as ExecutionContext } from "./path-CXT6xGPO.mjs";
+import { gt as PrefetchedIntent, it as SerializedNavigation, un as BasePage, yn as RouteParams } from "./session-DnB4ZC3x.mjs";
+//#region ../web/src/protocol.d.ts
+declare const FRAMEWORK_PROTOCOL_VERSION = 2;
+declare function getFrameworkBuildId(): string;
+interface WebHydration {
+  readonly tree?: SerializedNavigation;
+  readonly pages: PrefetchedIntent[];
+}
+interface WireEnvelope {
+  readonly protocolVersion: number;
+  readonly buildId: string;
+  readonly payload: WebHydration;
+}
+type WireDecodeResult = {
+  readonly status: "ready";
+  readonly data: WebHydration;
+} | {
+  readonly status: "fresh-load";
+  readonly code: "missing" | "invalid-json" | "protocol-mismatch" | "build-mismatch" | "invalid-payload";
+};
+declare function decodeWireEnvelope(value: unknown, buildId?: string): WireDecodeResult;
+//#endregion
+//#region ../web/src/application/server-controller-proxy.d.ts
+declare const SERVER_CONTROLLER_PATH = "/__finesoft/controller";
+interface ServerControllerRequest {
+  readonly intent: string;
+  readonly params: RouteParams;
+  readonly query: RouteParams;
+  readonly url: string;
+}
+/** The compiler replaces a complete server controller module with these inert references. */
+declare class ServerControllerProxy {
+  perform(params: RouteParams, execution: ExecutionContext, query?: RouteParams): Promise<BasePage>;
+}
+//#endregion
+export { WebHydration as a, decodeWireEnvelope as c, FRAMEWORK_PROTOCOL_VERSION as i, getFrameworkBuildId as l, ServerControllerProxy as n, WireDecodeResult as o, ServerControllerRequest as r, WireEnvelope as s, SERVER_CONTROLLER_PATH as t };
+//# sourceMappingURL=server-controller-proxy-BkVuVWVD.d.mts.map