@vkma.dev/router 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pajecawav
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/core/bridge-like.d.ts

@@ -0,0 +1,25 @@
+//#region src/core/bridge-like.d.ts
+/**
+ * The structural bridge contract: type-compatible with both
+ * `@vkontakte/vk-bridge` (whose subscribe handlers receive
+ * `{ detail: { type, data } }` CustomEvents) and `@vkma.dev/bridge`
+ * (flat `{ type, data }`). The router never hard-depends on either.
+ */
+export interface BridgeEventEnvelope {
+  type?: string;
+  data?: unknown;
+  detail?: {
+    type?: string;
+    data?: unknown;
+  };
+}
+export interface VkBridgeLike {
+  send(method: string, params?: Record<string, unknown>): Promise<unknown>;
+  subscribe(handler: (event: BridgeEventEnvelope) => void): () => void;
+}
+export declare function normalizeBridgeEvent(event: BridgeEventEnvelope): {
+  type: string;
+  data: unknown;
+} | null;
+//#endregion
+//# sourceMappingURL=bridge-like.d.ts.map

package/dist/core/bridge-like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-like.d.ts","names":[],"sources":["../../src/core/bridge-like.ts"],"mappings":";;;;;;;iBAOiB;EAChB;EACA;EACA;IAAW;IAAe;;;iBAGV;EAChB,KAAK,gBAAgB,SAAS,0BAA0B;EACxD,UAAU,UAAU,OAAO;;wBAGZ,qBACf,OAAO;EACH;EAAc"}

package/dist/core/bridge-like.js

@@ -0,0 +1,13 @@
+//#region src/core/bridge-like.ts
+function normalizeBridgeEvent(event) {
+	const type = event.detail?.type ?? event.type;
+	const data = event.detail !== void 0 ? event.detail.data : event.data;
+	return type !== void 0 ? {
+		type,
+		data
+	} : null;
+}
+//#endregion
+export { normalizeBridgeEvent };
+
+//# sourceMappingURL=bridge-like.js.map

package/dist/core/bridge-like.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-like.js","names":[],"sources":["../../src/core/bridge-like.ts"],"sourcesContent":["/**\n * The structural bridge contract: type-compatible with both\n * `@vkontakte/vk-bridge` (whose subscribe handlers receive\n * `{ detail: { type, data } }` CustomEvents) and `@vkma.dev/bridge`\n * (flat `{ type, data }`). The router never hard-depends on either.\n */\n\nexport interface BridgeEventEnvelope {\n\ttype?: string;\n\tdata?: unknown;\n\tdetail?: { type?: string; data?: unknown };\n}\n\nexport interface VkBridgeLike {\n\tsend(method: string, params?: Record<string, unknown>): Promise<unknown>;\n\tsubscribe(handler: (event: BridgeEventEnvelope) => void): () => void;\n}\n\nexport function normalizeBridgeEvent(\n\tevent: BridgeEventEnvelope,\n): { type: string; data: unknown } | null {\n\tconst type = event.detail?.type ?? event.type;\n\tconst data = event.detail !== undefined ? event.detail.data : event.data;\n\treturn type !== undefined ? { type, data } : null;\n}\n"],"mappings":";AAkBA,SAAgB,qBACf,OACyC;CACzC,MAAM,OAAO,MAAM,QAAQ,QAAQ,MAAM;CACzC,MAAM,OAAO,MAAM,WAAW,KAAA,IAAY,MAAM,OAAO,OAAO,MAAM;CACpE,OAAO,SAAS,KAAA,IAAY;EAAE;EAAM;CAAK,IAAI;AAC9C"}

package/dist/core/bridge-sync.d.ts

@@ -0,0 +1,37 @@
+import { VkBridgeLike } from "./bridge-like.js";
+//#region src/core/bridge-sync.d.ts
+export interface BridgeSyncOptions {
+  history: {
+    location: {
+      pathname: string;
+      search: string;
+      hash: string;
+    };
+    subscribe(listener: (event: {
+      location: {
+        pathname: string;
+        search: string;
+        hash: string;
+      };
+    }) => void): () => void;
+    replace(path: string): void;
+  };
+  bridge: VkBridgeLike;
+  /**
+   * SetLocation payload for a committed location. Defaults to the hash
+   * mode (the hash content); hash-param users pass the codecs from
+   * `createVkHistory`.
+   */
+  serializePayload?: (location: {
+    pathname: string;
+    search: string;
+    hash: string;
+  }) => string;
+  /** Router href from a SetLocation/ChangeFragment payload. */
+  parsePayload?: (payload: string) => string;
+}
+export declare function createBridgeSync(options: BridgeSyncOptions): {
+  destroy(): void;
+};
+//#endregion
+//# sourceMappingURL=bridge-sync.d.ts.map

package/dist/core/bridge-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-sync.d.ts","names":[],"sources":["../../src/core/bridge-sync.ts"],"mappings":";;iBAqBiB;EAChB;IACC;MAAY;MAAkB;MAAgB;;IAC9C,UACC,WAAW;MACV;QAAY;QAAkB;QAAgB;;;IAGhD,QAAQ;;EAET,QAAQ;;;;;;EAMR,oBAAoB;IAAY;IAAkB;IAAgB;;;EAElE,gBAAgB;;wBASD,iBAAiB,SAAS;EAAsB"}

package/dist/core/bridge-sync.js

@@ -0,0 +1,58 @@
+import { parseHashLocation, serializeHashLocation } from "./hash-params.js";
+import { normalizeBridgeEvent } from "./bridge-like.js";
+//#region src/core/bridge-sync.ts
+/**
+* The host↔app location sync contract:
+* - every committed history change → `VKWebAppSetLocation`
+*   (`replace_state: true`) so the host URL/share reflects the app;
+* - incoming `VKWebAppChangeFragment` / `VKWebAppLocationChanged`
+*   (host-initiated jumps) → `history.replace(href)`;
+* - loop protection: an incoming href equal to the current one is ignored.
+*
+* Payload codecs come from the history (they are mode-specific: hash mode
+* sends the hash content, hash-param mode sends `?path=…` preserving
+* foreign params). The initial location is sent once at creation.
+* Serialization happens from the history EVENT's location: subscribers are
+* notified synchronously before the microtask flush writes the URL, so
+* `window.location.hash` is stale by one entry at notify time.
+*/
+const LOCATION_EVENTS = /* @__PURE__ */ new Set(["VKWebAppChangeFragment", "VKWebAppLocationChanged"]);
+/** Hash-mode codecs are the defaults. */
+const serializeDefault = (location) => serializeHashLocation(location);
+const parseDefault = (payload) => parseHashLocation(payload);
+function createBridgeSync(options) {
+	const serializePayload = options.serializePayload ?? serializeDefault;
+	const parsePayload = options.parsePayload ?? parseDefault;
+	let lastSent = "";
+	const sendLocation = (location) => {
+		const payload = serializePayload(location);
+		if (payload !== lastSent) {
+			lastSent = payload;
+			options.bridge.send("VKWebAppSetLocation", {
+				location: payload,
+				replace_state: true
+			});
+		}
+	};
+	sendLocation(options.history.location);
+	const unsubscribeHistory = options.history.subscribe((event) => {
+		sendLocation(event.location);
+	});
+	const unsubscribeBridge = options.bridge.subscribe((rawEvent) => {
+		const event = normalizeBridgeEvent(rawEvent);
+		if (event === null || !LOCATION_EVENTS.has(event.type)) return;
+		const data = event.data;
+		if (!data?.location) return;
+		const incoming = parsePayload(data.location);
+		if (incoming === `${options.history.location.pathname}${options.history.location.search}`) return;
+		options.history.replace(incoming);
+	});
+	return { destroy() {
+		unsubscribeHistory();
+		unsubscribeBridge();
+	} };
+}
+//#endregion
+export { createBridgeSync };
+
+//# sourceMappingURL=bridge-sync.js.map

package/dist/core/bridge-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-sync.js","names":[],"sources":["../../src/core/bridge-sync.ts"],"sourcesContent":["import { normalizeBridgeEvent, type VkBridgeLike } from \"./bridge-like.ts\";\nimport { parseHashLocation, serializeHashLocation } from \"./hash-params.ts\";\n\n/**\n * The host↔app location sync contract:\n * - every committed history change → `VKWebAppSetLocation`\n *   (`replace_state: true`) so the host URL/share reflects the app;\n * - incoming `VKWebAppChangeFragment` / `VKWebAppLocationChanged`\n *   (host-initiated jumps) → `history.replace(href)`;\n * - loop protection: an incoming href equal to the current one is ignored.\n *\n * Payload codecs come from the history (they are mode-specific: hash mode\n * sends the hash content, hash-param mode sends `?path=…` preserving\n * foreign params). The initial location is sent once at creation.\n * Serialization happens from the history EVENT's location: subscribers are\n * notified synchronously before the microtask flush writes the URL, so\n * `window.location.hash` is stale by one entry at notify time.\n */\n\nconst LOCATION_EVENTS = new Set([\"VKWebAppChangeFragment\", \"VKWebAppLocationChanged\"]);\n\nexport interface BridgeSyncOptions {\n\thistory: {\n\t\tlocation: { pathname: string; search: string; hash: string };\n\t\tsubscribe(\n\t\t\tlistener: (event: {\n\t\t\t\tlocation: { pathname: string; search: string; hash: string };\n\t\t\t}) => void,\n\t\t): () => void;\n\t\treplace(path: string): void;\n\t};\n\tbridge: VkBridgeLike;\n\t/**\n\t * SetLocation payload for a committed location. Defaults to the hash\n\t * mode (the hash content); hash-param users pass the codecs from\n\t * `createVkHistory`.\n\t */\n\tserializePayload?: (location: { pathname: string; search: string; hash: string }) => string;\n\t/** Router href from a SetLocation/ChangeFragment payload. */\n\tparsePayload?: (payload: string) => string;\n}\n\n/** Hash-mode codecs are the defaults. */\nconst serializeDefault = (location: { pathname: string; search: string; hash: string }): string =>\n\tserializeHashLocation(location);\n\nconst parseDefault = (payload: string): string => parseHashLocation(payload);\n\nexport function createBridgeSync(options: BridgeSyncOptions): { destroy(): void } {\n\tconst serializePayload = options.serializePayload ?? serializeDefault;\n\tconst parsePayload = options.parsePayload ?? parseDefault;\n\tlet lastSent = \"\";\n\n\tconst sendLocation = (location: { pathname: string; search: string; hash: string }): void => {\n\t\tconst payload = serializePayload(location);\n\t\tif (payload !== lastSent) {\n\t\t\tlastSent = payload;\n\t\t\tvoid options.bridge.send(\"VKWebAppSetLocation\", {\n\t\t\t\tlocation: payload,\n\t\t\t\treplace_state: true,\n\t\t\t});\n\t\t}\n\t};\n\n\t// the host must learn the location the app started at\n\tsendLocation(options.history.location);\n\n\tconst unsubscribeHistory = options.history.subscribe(event => {\n\t\tsendLocation(event.location);\n\t});\n\n\tconst unsubscribeBridge = options.bridge.subscribe(rawEvent => {\n\t\tconst event = normalizeBridgeEvent(rawEvent);\n\t\tif (event === null || !LOCATION_EVENTS.has(event.type)) {\n\t\t\treturn;\n\t\t}\n\t\tconst data = event.data as { location?: string } | undefined;\n\t\tif (!data?.location) {\n\t\t\treturn; // malformed — the host always sends a location; never act on it\n\t\t}\n\t\tconst incoming = parsePayload(data.location);\n\t\tconst current = `${options.history.location.pathname}${options.history.location.search}`;\n\t\tif (incoming === current) {\n\t\t\treturn; // echo of our own location — loop protection\n\t\t}\n\t\toptions.history.replace(incoming);\n\t});\n\n\treturn {\n\t\tdestroy() {\n\t\t\tunsubscribeHistory();\n\t\t\tunsubscribeBridge();\n\t\t},\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,MAAM,kCAAkB,IAAI,IAAI,CAAC,0BAA0B,yBAAyB,CAAC;;AAwBrF,MAAM,oBAAoB,aACzB,sBAAsB,QAAQ;AAE/B,MAAM,gBAAgB,YAA4B,kBAAkB,OAAO;AAE3E,SAAgB,iBAAiB,SAAiD;CACjF,MAAM,mBAAmB,QAAQ,oBAAoB;CACrD,MAAM,eAAe,QAAQ,gBAAgB;CAC7C,IAAI,WAAW;CAEf,MAAM,gBAAgB,aAAuE;EAC5F,MAAM,UAAU,iBAAiB,QAAQ;EACzC,IAAI,YAAY,UAAU;GACzB,WAAW;GACX,QAAa,OAAO,KAAK,uBAAuB;IAC/C,UAAU;IACV,eAAe;GAChB,CAAC;EACF;CACD;CAGA,aAAa,QAAQ,QAAQ,QAAQ;CAErC,MAAM,qBAAqB,QAAQ,QAAQ,WAAU,UAAS;EAC7D,aAAa,MAAM,QAAQ;CAC5B,CAAC;CAED,MAAM,oBAAoB,QAAQ,OAAO,WAAU,aAAY;EAC9D,MAAM,QAAQ,qBAAqB,QAAQ;EAC3C,IAAI,UAAU,QAAQ,CAAC,gBAAgB,IAAI,MAAM,IAAI,GACpD;EAED,MAAM,OAAO,MAAM;EACnB,IAAI,CAAC,MAAM,UACV;EAED,MAAM,WAAW,aAAa,KAAK,QAAQ;EAE3C,IAAI,aAAa,GADE,QAAQ,QAAQ,SAAS,WAAW,QAAQ,QAAQ,SAAS,UAE/E;EAED,QAAQ,QAAQ,QAAQ,QAAQ;CACjC,CAAC;CAED,OAAO,EACN,UAAU;EACT,mBAAmB;EACnB,kBAAkB;CACnB,EACD;AACD"}

package/dist/core/hash-params.d.ts

@@ -0,0 +1,40 @@
+//#region src/core/hash-params.d.ts
+/**
+ * Hash payload helpers for the VK history.
+ *
+ * Two URL modes:
+ * - `hash` (default): the hash IS the location (`#/item/7?tab=x`),
+ *   TanStack-style — parity with the old `createHashRouter`.
+ * - `hash-param`: the whole router location rides in ONE hash query param
+ *   (`#?path=%2Fitem%2F7`), foreign hash params (launch params, UTM) are
+ *   preserved next to it and never leak into the router's search. The real
+ *   `location.search` — where VK puts launch params on the web platform —
+ *   is never touched. Parity with the old `createHashParamRouter`.
+ *
+ * Both read paths tolerate LEGACY deep links written by the other mode
+ * (`#/path` resolves in hash-param mode, `#?path=…` resolves in hash
+ * mode); writes always use the active mode's canonical format.
+ */
+export declare function readHashParams(win: Window): URLSearchParams;
+/**
+ * Router href from the document hash, tolerant to both modes:
+ * `#?path=%2Flist&x=1` → `/list` (hash-param), `#/list?x=1` → `/list?x=1`
+ * (hash), empty or foreign hash → `/`.
+ */
+export declare function readHrefFromHash(win: Window, pathParam: string): string;
+/** Serialize a router href into the hash, preserving foreign params. */
+export declare function writeHashParams(win: Window, pathParam: string, href: string): string;
+/** Hash content (`?…` string) for a router href — the SetLocation payload. */
+export declare function serializeHashPayload(win: Window, pathParam: string, href: string): string;
+/** Extract the router href from a SetLocation/ChangeFragment payload. */
+export declare function parseHashPayload(payload: string, pathParam: string): string;
+/** Hash-mode SetLocation payload: the hash content IS the location. */
+export declare function serializeHashLocation(location: {
+  pathname: string;
+  search: string;
+  hash: string;
+}): string;
+/** Hash-mode payload → router href (normalized to a leading slash). */
+export declare function parseHashLocation(payload: string): string;
+//#endregion
+//# sourceMappingURL=hash-params.d.ts.map

package/dist/core/hash-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-params.d.ts","names":[],"sources":["../../src/core/hash-params.ts"],"mappings":";;;;;;;;;;;;;;;;;wBAiBgB,eAAe,KAAK,SAAS;;;;;;wBAS7B,iBAAiB,KAAK,QAAQ;;wBAY9B,gBAAgB,KAAK,QAAQ,mBAAmB;;wBAOhD,qBAAqB,KAAK,QAAQ,mBAAmB;;wBAOrD,iBAAiB,iBAAiB;;wBASlC,sBAAsB;EACrC;EACA;EACA;;;wBAMe,kBAAkB"}

package/dist/core/hash-params.js

@@ -0,0 +1,60 @@
+//#region src/core/hash-params.ts
+/**
+* Hash payload helpers for the VK history.
+*
+* Two URL modes:
+* - `hash` (default): the hash IS the location (`#/item/7?tab=x`),
+*   TanStack-style — parity with the old `createHashRouter`.
+* - `hash-param`: the whole router location rides in ONE hash query param
+*   (`#?path=%2Fitem%2F7`), foreign hash params (launch params, UTM) are
+*   preserved next to it and never leak into the router's search. The real
+*   `location.search` — where VK puts launch params on the web platform —
+*   is never touched. Parity with the old `createHashParamRouter`.
+*
+* Both read paths tolerate LEGACY deep links written by the other mode
+* (`#/path` resolves in hash-param mode, `#?path=…` resolves in hash
+* mode); writes always use the active mode's canonical format.
+*/
+function readHashParams(win) {
+	return new URLSearchParams(win.location.hash.replace(/^#\?/, ""));
+}
+/**
+* Router href from the document hash, tolerant to both modes:
+* `#?path=%2Flist&x=1` → `/list` (hash-param), `#/list?x=1` → `/list?x=1`
+* (hash), empty or foreign hash → `/`.
+*/
+function readHrefFromHash(win, pathParam) {
+	const hash = win.location.hash;
+	if (hash.startsWith("#?")) return new URLSearchParams(hash.slice(2)).get(pathParam) ?? "/";
+	if (hash.startsWith("#/")) return hash.slice(1);
+	return "/";
+}
+/** Serialize a router href into the hash, preserving foreign params. */
+function writeHashParams(win, pathParam, href) {
+	const params = readHashParams(win);
+	params.set(pathParam, href);
+	return `${win.location.pathname}${win.location.search}#?${params.toString()}`;
+}
+/** Hash content (`?…` string) for a router href — the SetLocation payload. */
+function serializeHashPayload(win, pathParam, href) {
+	const params = readHashParams(win);
+	params.set(pathParam, href);
+	return `?${params.toString()}`;
+}
+/** Extract the router href from a SetLocation/ChangeFragment payload. */
+function parseHashPayload(payload, pathParam) {
+	if (payload.startsWith("/")) return payload;
+	return new URLSearchParams(payload.replace(/^\?/, "")).get(pathParam) ?? "/";
+}
+/** Hash-mode SetLocation payload: the hash content IS the location. */
+function serializeHashLocation(location) {
+	return `${location.pathname}${location.search}${location.hash}`;
+}
+/** Hash-mode payload → router href (normalized to a leading slash). */
+function parseHashLocation(payload) {
+	return payload.startsWith("/") ? payload : `/${payload}`;
+}
+//#endregion
+export { parseHashLocation, parseHashPayload, readHashParams, readHrefFromHash, serializeHashLocation, serializeHashPayload, writeHashParams };
+
+//# sourceMappingURL=hash-params.js.map

package/dist/core/hash-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-params.js","names":[],"sources":["../../src/core/hash-params.ts"],"sourcesContent":["/**\n * Hash payload helpers for the VK history.\n *\n * Two URL modes:\n * - `hash` (default): the hash IS the location (`#/item/7?tab=x`),\n *   TanStack-style — parity with the old `createHashRouter`.\n * - `hash-param`: the whole router location rides in ONE hash query param\n *   (`#?path=%2Fitem%2F7`), foreign hash params (launch params, UTM) are\n *   preserved next to it and never leak into the router's search. The real\n *   `location.search` — where VK puts launch params on the web platform —\n *   is never touched. Parity with the old `createHashParamRouter`.\n *\n * Both read paths tolerate LEGACY deep links written by the other mode\n * (`#/path` resolves in hash-param mode, `#?path=…` resolves in hash\n * mode); writes always use the active mode's canonical format.\n */\n\nexport function readHashParams(win: Window): URLSearchParams {\n\treturn new URLSearchParams(win.location.hash.replace(/^#\\?/, \"\"));\n}\n\n/**\n * Router href from the document hash, tolerant to both modes:\n * `#?path=%2Flist&x=1` → `/list` (hash-param), `#/list?x=1` → `/list?x=1`\n * (hash), empty or foreign hash → `/`.\n */\nexport function readHrefFromHash(win: Window, pathParam: string): string {\n\tconst hash = win.location.hash;\n\tif (hash.startsWith(\"#?\")) {\n\t\treturn new URLSearchParams(hash.slice(2)).get(pathParam) ?? \"/\";\n\t}\n\tif (hash.startsWith(\"#/\")) {\n\t\treturn hash.slice(1);\n\t}\n\treturn \"/\";\n}\n\n/** Serialize a router href into the hash, preserving foreign params. */\nexport function writeHashParams(win: Window, pathParam: string, href: string): string {\n\tconst params = readHashParams(win);\n\tparams.set(pathParam, href);\n\treturn `${win.location.pathname}${win.location.search}#?${params.toString()}`;\n}\n\n/** Hash content (`?…` string) for a router href — the SetLocation payload. */\nexport function serializeHashPayload(win: Window, pathParam: string, href: string): string {\n\tconst params = readHashParams(win);\n\tparams.set(pathParam, href);\n\treturn `?${params.toString()}`;\n}\n\n/** Extract the router href from a SetLocation/ChangeFragment payload. */\nexport function parseHashPayload(payload: string, pathParam: string): string {\n\tif (payload.startsWith(\"/\")) {\n\t\t// legacy plain-hash payload (old createHashRouter hosts)\n\t\treturn payload;\n\t}\n\treturn new URLSearchParams(payload.replace(/^\\?/, \"\")).get(pathParam) ?? \"/\";\n}\n\n/** Hash-mode SetLocation payload: the hash content IS the location. */\nexport function serializeHashLocation(location: {\n\tpathname: string;\n\tsearch: string;\n\thash: string;\n}): string {\n\treturn `${location.pathname}${location.search}${location.hash}`;\n}\n\n/** Hash-mode payload → router href (normalized to a leading slash). */\nexport function parseHashLocation(payload: string): string {\n\treturn payload.startsWith(\"/\") ? payload : `/${payload}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,SAAgB,eAAe,KAA8B;CAC5D,OAAO,IAAI,gBAAgB,IAAI,SAAS,KAAK,QAAQ,QAAQ,EAAE,CAAC;AACjE;;;;;;AAOA,SAAgB,iBAAiB,KAAa,WAA2B;CACxE,MAAM,OAAO,IAAI,SAAS;CAC1B,IAAI,KAAK,WAAW,IAAI,GACvB,OAAO,IAAI,gBAAgB,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,SAAS,KAAK;CAE7D,IAAI,KAAK,WAAW,IAAI,GACvB,OAAO,KAAK,MAAM,CAAC;CAEpB,OAAO;AACR;;AAGA,SAAgB,gBAAgB,KAAa,WAAmB,MAAsB;CACrF,MAAM,SAAS,eAAe,GAAG;CACjC,OAAO,IAAI,WAAW,IAAI;CAC1B,OAAO,GAAG,IAAI,SAAS,WAAW,IAAI,SAAS,OAAO,IAAI,OAAO,SAAS;AAC3E;;AAGA,SAAgB,qBAAqB,KAAa,WAAmB,MAAsB;CAC1F,MAAM,SAAS,eAAe,GAAG;CACjC,OAAO,IAAI,WAAW,IAAI;CAC1B,OAAO,IAAI,OAAO,SAAS;AAC5B;;AAGA,SAAgB,iBAAiB,SAAiB,WAA2B;CAC5E,IAAI,QAAQ,WAAW,GAAG,GAEzB,OAAO;CAER,OAAO,IAAI,gBAAgB,QAAQ,QAAQ,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,SAAS,KAAK;AAC1E;;AAGA,SAAgB,sBAAsB,UAI3B;CACV,OAAO,GAAG,SAAS,WAAW,SAAS,SAAS,SAAS;AAC1D;;AAGA,SAAgB,kBAAkB,SAAyB;CAC1D,OAAO,QAAQ,WAAW,GAAG,IAAI,UAAU,IAAI;AAChD"}

package/dist/core/loose-route.js

@@ -0,0 +1,9 @@
+//#region src/core/loose-route.ts
+/** Read a route out of the router's registered tree without the cast noise. */
+function looseRouteOf(router, routeId) {
+	return router.routesById[routeId];
+}
+//#endregion
+export { looseRouteOf };
+
+//# sourceMappingURL=loose-route.js.map

package/dist/core/loose-route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loose-route.js","names":[],"sources":["../../src/core/loose-route.ts"],"sourcesContent":["/**\n * Loosely-typed view of a registered route. `AnyRoute`'s options bag is\n * generic-erased (`any`), so every consumer of `router.routesById` needs\n * the same structural recast — this owns it once.\n */\nexport interface LooseRoute {\n\toptions: { staticData?: { panel?: string; modal?: string } };\n\tfullPath?: string;\n}\n\n/** Read a route out of the router's registered tree without the cast noise. */\nexport function looseRouteOf(\n\trouter: { routesById: unknown },\n\trouteId: string,\n): LooseRoute | undefined {\n\treturn (router.routesById as Record<string, LooseRoute>)[routeId];\n}\n"],"mappings":";;AAWA,SAAgB,aACf,QACA,SACyB;CACzB,OAAQ,OAAO,WAA0C;AAC1D"}

package/dist/core/panels-stack.d.ts

@@ -0,0 +1,28 @@
+//#region src/core/panels-stack.d.ts
+/**
+ * Mirror of the browser history stack in terms of VKUI panel ids, indexed
+ * by `location.state.__TSR_index` (the absolute position in the history
+ * stack). Replaces the old router's key-matching ViewHistory with direct
+ * indexing. Pure — the React binding gates writes on the router's
+ * `status === "idle"` (the location commit lands a render before match
+ * resolution, so a naive write records the stale panel at the new index).
+ */
+export interface PanelsStackState {
+  /** panel id per history index (null = unknown entry) */
+  entries: Array<string | null>;
+  /** current history index */
+  cursor: number;
+}
+export declare const initialPanelsStack: () => PanelsStackState;
+/**
+ * @param index `location.state.__TSR_index`, or null when the history entry
+ *              carries no TanStack state (manual hash edit / foreign entry).
+ */
+export declare function applyLocation(prev: PanelsStackState, index: number | null, panel: string): PanelsStackState;
+/**
+ * VKUI `View.history` prop: panels in open order. Overlay entries never
+ * reach this stack (they live in history.state, not as panels).
+ */
+export declare function panelsHistoryOf(state: PanelsStackState): string[];
+//#endregion
+//# sourceMappingURL=panels-stack.d.ts.map

package/dist/core/panels-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panels-stack.d.ts","names":[],"sources":["../../src/core/panels-stack.ts"],"mappings":";;;;;;;;;iBASiB;;EAEhB,SAAS;;EAET;;qBAGY,0BAAyB;;;;;wBAStB,cACf,MAAM,kBACN,sBACA,gBACE;;;;;wBA8Ca,gBAAgB,OAAO"}

package/dist/core/panels-stack.js

@@ -0,0 +1,60 @@
+//#region src/core/panels-stack.ts
+const initialPanelsStack = () => ({
+	entries: [],
+	cursor: -1
+});
+/**
+* @param index `location.state.__TSR_index`, or null when the history entry
+*              carries no TanStack state (manual hash edit / foreign entry).
+*/
+function applyLocation(prev, index, panel) {
+	const at = index ?? prev.cursor + 1;
+	if (prev.cursor === -1) {
+		const filled = [];
+		for (let i = 0; i <= at; i++) filled[i] = i === at ? panel : null;
+		return {
+			entries: filled,
+			cursor: at
+		};
+	}
+	if (at > prev.cursor) {
+		const truncated = prev.entries.slice(0, prev.cursor + 1);
+		const filled = [];
+		for (let i = 0; i <= at; i++) filled[i] = i === at ? panel : truncated[i] ?? null;
+		return {
+			entries: filled,
+			cursor: at
+		};
+	}
+	if (at === prev.cursor) {
+		const entries = [...prev.entries];
+		entries[at] = panel;
+		return {
+			entries,
+			cursor: at
+		};
+	}
+	const filled = [];
+	for (let i = 0; i <= at; i++) filled[i] = prev.entries[i] ?? null;
+	if (filled[at] === null) filled[at] = panel;
+	return {
+		entries: filled,
+		cursor: at
+	};
+}
+/**
+* VKUI `View.history` prop: panels in open order. Overlay entries never
+* reach this stack (they live in history.state, not as panels).
+*/
+function panelsHistoryOf(state) {
+	const out = [];
+	for (let i = 0; i <= state.cursor; i++) {
+		const panel = state.entries[i];
+		if (panel) out.push(panel);
+	}
+	return out;
+}
+//#endregion
+export { applyLocation, initialPanelsStack, panelsHistoryOf };
+
+//# sourceMappingURL=panels-stack.js.map

package/dist/core/panels-stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"panels-stack.js","names":[],"sources":["../../src/core/panels-stack.ts"],"sourcesContent":["/**\n * Mirror of the browser history stack in terms of VKUI panel ids, indexed\n * by `location.state.__TSR_index` (the absolute position in the history\n * stack). Replaces the old router's key-matching ViewHistory with direct\n * indexing. Pure — the React binding gates writes on the router's\n * `status === \"idle\"` (the location commit lands a render before match\n * resolution, so a naive write records the stale panel at the new index).\n */\n\nexport interface PanelsStackState {\n\t/** panel id per history index (null = unknown entry) */\n\tentries: Array<string | null>;\n\t/** current history index */\n\tcursor: number;\n}\n\nexport const initialPanelsStack = (): PanelsStackState => ({\n\tentries: [],\n\tcursor: -1,\n});\n\n/**\n * @param index `location.state.__TSR_index`, or null when the history entry\n *              carries no TanStack state (manual hash edit / foreign entry).\n */\nexport function applyLocation(\n\tprev: PanelsStackState,\n\tindex: number | null,\n\tpanel: string,\n): PanelsStackState {\n\tconst at = index ?? prev.cursor + 1;\n\n\tif (prev.cursor === -1) {\n\t\t// init (cold start / reload / deep link): anchor at the real history\n\t\t// index — `__TSR_index` survives reloads in history.state. Earlier\n\t\t// slots are unknown (null) and skipped by panelsHistoryOf.\n\t\tconst filled: Array<string | null> = [];\n\t\tfor (let i = 0; i <= at; i++) {\n\t\t\tfilled[i] = i === at ? panel : null;\n\t\t}\n\t\treturn { entries: filled, cursor: at };\n\t}\n\n\tif (at > prev.cursor) {\n\t\t// push: truncate the forward branch, then place the panel at `at`\n\t\tconst truncated = prev.entries.slice(0, prev.cursor + 1);\n\t\tconst filled: Array<string | null> = [];\n\t\tfor (let i = 0; i <= at; i++) {\n\t\t\tfilled[i] = i === at ? panel : (truncated[i] ?? null);\n\t\t}\n\t\treturn { entries: filled, cursor: at };\n\t}\n\n\tif (at === prev.cursor) {\n\t\t// replace (same slot, new location)\n\t\tconst entries = [...prev.entries];\n\t\tentries[at] = panel;\n\t\treturn { entries, cursor: at };\n\t}\n\n\t// pop (back/forward into a known or unknown earlier slot)\n\tconst filled: Array<string | null> = [];\n\tfor (let i = 0; i <= at; i++) {\n\t\tfilled[i] = prev.entries[i] ?? null;\n\t}\n\tif (filled[at] === null) {\n\t\tfilled[at] = panel;\n\t}\n\treturn { entries: filled, cursor: at };\n}\n\n/**\n * VKUI `View.history` prop: panels in open order. Overlay entries never\n * reach this stack (they live in history.state, not as panels).\n */\nexport function panelsHistoryOf(state: PanelsStackState): string[] {\n\tconst out: string[] = [];\n\tfor (let i = 0; i <= state.cursor; i++) {\n\t\tconst panel = state.entries[i];\n\t\tif (panel) {\n\t\t\tout.push(panel);\n\t\t}\n\t}\n\treturn out;\n}\n"],"mappings":";AAgBA,MAAa,4BAA8C;CAC1D,SAAS,CAAC;CACV,QAAQ;AACT;;;;;AAMA,SAAgB,cACf,MACA,OACA,OACmB;CACnB,MAAM,KAAK,SAAS,KAAK,SAAS;CAElC,IAAI,KAAK,WAAW,IAAI;EAIvB,MAAM,SAA+B,CAAC;EACtC,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,KACxB,OAAO,KAAK,MAAM,KAAK,QAAQ;EAEhC,OAAO;GAAE,SAAS;GAAQ,QAAQ;EAAG;CACtC;CAEA,IAAI,KAAK,KAAK,QAAQ;EAErB,MAAM,YAAY,KAAK,QAAQ,MAAM,GAAG,KAAK,SAAS,CAAC;EACvD,MAAM,SAA+B,CAAC;EACtC,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,KACxB,OAAO,KAAK,MAAM,KAAK,QAAS,UAAU,MAAM;EAEjD,OAAO;GAAE,SAAS;GAAQ,QAAQ;EAAG;CACtC;CAEA,IAAI,OAAO,KAAK,QAAQ;EAEvB,MAAM,UAAU,CAAC,GAAG,KAAK,OAAO;EAChC,QAAQ,MAAM;EACd,OAAO;GAAE;GAAS,QAAQ;EAAG;CAC9B;CAGA,MAAM,SAA+B,CAAC;CACtC,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI,KACxB,OAAO,KAAK,KAAK,QAAQ,MAAM;CAEhC,IAAI,OAAO,QAAQ,MAClB,OAAO,MAAM;CAEd,OAAO;EAAE,SAAS;EAAQ,QAAQ;CAAG;AACtC;;;;;AAMA,SAAgB,gBAAgB,OAAmC;CAClE,MAAM,MAAgB,CAAC;CACvB,KAAK,IAAI,IAAI,GAAG,KAAK,MAAM,QAAQ,KAAK;EACvC,MAAM,QAAQ,MAAM,QAAQ;EAC5B,IAAI,OACH,IAAI,KAAK,KAAK;CAEhB;CACA,OAAO;AACR"}

package/dist/core/state-keys.d.ts

@@ -0,0 +1,10 @@
+//#region src/core/state-keys.d.ts
+/** The key the popout overlay rides under in `history.state`. */
+export declare const POPOUT_STATE_KEY = "vkma:popout";
+export interface PopoutState {
+  id: string;
+  props?: Record<string, unknown>;
+}
+export declare function readPopoutState(state: unknown): PopoutState | undefined;
+//#endregion
+//# sourceMappingURL=state-keys.d.ts.map

package/dist/core/state-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-keys.d.ts","names":[],"sources":["../../src/core/state-keys.ts"],"mappings":";;qBACa;iBAEI;EAChB;EACA,QAAQ;;wBAqBO,gBAAgB,iBAAiB"}

package/dist/core/state-keys.js

@@ -0,0 +1,21 @@
+//#region src/core/state-keys.ts
+/** The key the popout overlay rides under in `history.state`. */
+const POPOUT_STATE_KEY = "vkma:popout";
+/** The key runtime modal props ride under in `history.state`. */
+const MODAL_STATE_KEY = "vkma:modal";
+function readModalState(state) {
+	if (state !== null && typeof state === "object" && "vkma:modal" in state) {
+		const modal = state[MODAL_STATE_KEY];
+		if (modal !== null && typeof modal === "object") return modal;
+	}
+}
+function readPopoutState(state) {
+	if (state !== null && typeof state === "object" && "vkma:popout" in state) {
+		const popout = state[POPOUT_STATE_KEY];
+		if (popout !== null && typeof popout === "object" && typeof popout.id === "string") return popout;
+	}
+}
+//#endregion
+export { MODAL_STATE_KEY, POPOUT_STATE_KEY, readModalState, readPopoutState };
+
+//# sourceMappingURL=state-keys.js.map

package/dist/core/state-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-keys.js","names":[],"sources":["../../src/core/state-keys.ts"],"sourcesContent":["/** The key the popout overlay rides under in `history.state`. */\nexport const POPOUT_STATE_KEY = \"vkma:popout\";\n\nexport interface PopoutState {\n\tid: string;\n\tprops?: Record<string, unknown>;\n}\n\n/** The key runtime modal props ride under in `history.state`. */\nexport const MODAL_STATE_KEY = \"vkma:modal\";\n\nexport interface ModalState {\n\t/** Serializable props passed via `showModal({ props })`. */\n\tprops?: unknown;\n}\n\nexport function readModalState(state: unknown): ModalState | undefined {\n\tif (state !== null && typeof state === \"object\" && MODAL_STATE_KEY in state) {\n\t\tconst modal = (state as Record<string, unknown>)[MODAL_STATE_KEY];\n\t\tif (modal !== null && typeof modal === \"object\") {\n\t\t\treturn modal;\n\t\t}\n\t}\n\treturn undefined;\n}\n\nexport function readPopoutState(state: unknown): PopoutState | undefined {\n\tif (state !== null && typeof state === \"object\" && POPOUT_STATE_KEY in state) {\n\t\tconst popout = (state as Record<string, unknown>)[POPOUT_STATE_KEY];\n\t\tif (\n\t\t\tpopout !== null &&\n\t\t\ttypeof popout === \"object\" &&\n\t\t\ttypeof (popout as PopoutState).id === \"string\"\n\t\t) {\n\t\t\treturn popout as PopoutState;\n\t\t}\n\t}\n\treturn undefined;\n}\n"],"mappings":";;AACA,MAAa,mBAAmB;;AAQhC,MAAa,kBAAkB;AAO/B,SAAgB,eAAe,OAAwC;CACtE,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAA,gBAA+B,OAAO;EAC5E,MAAM,QAAS,MAAkC;EACjD,IAAI,UAAU,QAAQ,OAAO,UAAU,UACtC,OAAO;CAET;AAED;AAEA,SAAgB,gBAAgB,OAAyC;CACxE,IAAI,UAAU,QAAQ,OAAO,UAAU,YAAA,iBAAgC,OAAO;EAC7E,MAAM,SAAU,MAAkC;EAClD,IACC,WAAW,QACX,OAAO,WAAW,YAClB,OAAQ,OAAuB,OAAO,UAEtC,OAAO;CAET;AAED"}

package/dist/core/swipe-back.d.ts

@@ -0,0 +1,25 @@
+import { VkBridgeLike } from "./bridge-like.js";
+//#region src/core/swipe-back.d.ts
+export interface SwipeBackManagerOptions {
+  bridge: VkBridgeLike;
+  history: {
+    location: {
+      state?: {
+        __TSR_index?: number;
+      };
+    };
+    subscribe(listener: () => void): () => void;
+  };
+  /**
+   * Hard opt-out: the native gesture is never enabled, whatever the
+   * history position or an override says. Default `true`.
+   */
+  enabled?: boolean;
+}
+export declare function createSwipeBackManager(options: SwipeBackManagerOptions): {
+  destroy: () => void;
+  /** Manual override — `null` returns to the automatic decision. */
+  setOverride: (enabled: boolean | null) => void;
+};
+//#endregion
+//# sourceMappingURL=swipe-back.d.ts.map

package/dist/core/swipe-back.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swipe-back.d.ts","names":[],"sources":["../../src/core/swipe-back.ts"],"mappings":";;iBA0BiB;EAChB,QAAQ;EACR;IACC;MAAY;QAAU;;;IACtB,UAAU;;;;;;EAMX;;wBAGe,uBAAuB,SAAS;EAC/C;;EAEA,cAAc"}

package/dist/core/swipe-back.js

@@ -0,0 +1,53 @@
+//#region src/core/swipe-back.ts
+/**
+* Auto swipe-back management: the native gesture
+* (`VKWebAppEnableSwipeBack` / `VKWebAppSetSwipeSettings { history }`) is
+* enabled while the app can go back in its own history and disabled on the
+* first entry — where the system back must close the app. Unsupported
+* platforms (web) answer with error code 6; that is silenced, like the old
+* router did.
+*
+* Two manual layers on top of the automatic decision:
+* - `enabled: false` is a hard opt-out — the gesture is never enabled
+*   (an app that drives the gesture itself, or none at all);
+* - `setOverride(boolean)` — fed by `useEnableSwipeBack` — replaces the
+*   automatic decision while set; `null` returns to it.
+*/
+/** The one active manager — `useEnableSwipeBack` talks to the last created
+* one (a mini app has exactly one history). `destroy` unregisters. */
+let activeManager = null;
+/** Manual override slot behind `useEnableSwipeBack`. */
+function setSwipeBackOverride(enabled) {
+	activeManager?.setOverride(enabled);
+}
+function createSwipeBackManager(options) {
+	let lastEnabled = null;
+	let override = null;
+	const sync = () => {
+		const index = options.history.location.state?.__TSR_index;
+		const auto = index === void 0 ? false : index > 0;
+		const enabled = options.enabled === false ? false : override ?? auto;
+		if (enabled === lastEnabled) return;
+		lastEnabled = enabled;
+		options.bridge.send("VKWebAppSetSwipeSettings", { history: enabled }).catch(() => {});
+		options.bridge.send(enabled ? "VKWebAppEnableSwipeBack" : "VKWebAppDisableSwipeBack").catch(() => {});
+	};
+	sync();
+	const unsubscribe = options.history.subscribe(sync);
+	const manager = { setOverride: (enabled) => {
+		override = enabled;
+		sync();
+	} };
+	activeManager = manager;
+	return {
+		setOverride: manager.setOverride,
+		destroy: () => {
+			unsubscribe();
+			if (activeManager === manager) activeManager = null;
+		}
+	};
+}
+//#endregion
+export { createSwipeBackManager, setSwipeBackOverride };
+
+//# sourceMappingURL=swipe-back.js.map

package/dist/core/swipe-back.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swipe-back.js","names":[],"sources":["../../src/core/swipe-back.ts"],"sourcesContent":["import type { VkBridgeLike } from \"./bridge-like.ts\";\n\n/**\n * Auto swipe-back management: the native gesture\n * (`VKWebAppEnableSwipeBack` / `VKWebAppSetSwipeSettings { history }`) is\n * enabled while the app can go back in its own history and disabled on the\n * first entry — where the system back must close the app. Unsupported\n * platforms (web) answer with error code 6; that is silenced, like the old\n * router did.\n *\n * Two manual layers on top of the automatic decision:\n * - `enabled: false` is a hard opt-out — the gesture is never enabled\n *   (an app that drives the gesture itself, or none at all);\n * - `setOverride(boolean)` — fed by `useEnableSwipeBack` — replaces the\n *   automatic decision while set; `null` returns to it.\n */\n\n/** The one active manager — `useEnableSwipeBack` talks to the last created\n * one (a mini app has exactly one history). `destroy` unregisters. */\nlet activeManager: { setOverride(enabled: boolean | null): void } | null = null;\n\n/** Manual override slot behind `useEnableSwipeBack`. */\nexport function setSwipeBackOverride(enabled: boolean | null): void {\n\tactiveManager?.setOverride(enabled);\n}\n\nexport interface SwipeBackManagerOptions {\n\tbridge: VkBridgeLike;\n\thistory: {\n\t\tlocation: { state?: { __TSR_index?: number } };\n\t\tsubscribe(listener: () => void): () => void;\n\t};\n\t/**\n\t * Hard opt-out: the native gesture is never enabled, whatever the\n\t * history position or an override says. Default `true`.\n\t */\n\tenabled?: boolean;\n}\n\nexport function createSwipeBackManager(options: SwipeBackManagerOptions): {\n\tdestroy: () => void;\n\t/** Manual override — `null` returns to the automatic decision. */\n\tsetOverride: (enabled: boolean | null) => void;\n} {\n\tlet lastEnabled: boolean | null = null;\n\tlet override: boolean | null = null;\n\n\tconst sync = (): void => {\n\t\tconst index = options.history.location.state?.__TSR_index;\n\t\tconst auto = index === undefined ? false : index > 0;\n\t\tconst enabled = options.enabled === false ? false : (override ?? auto);\n\t\tif (enabled === lastEnabled) {\n\t\t\treturn;\n\t\t}\n\t\tlastEnabled = enabled;\n\t\tvoid options.bridge.send(\"VKWebAppSetSwipeSettings\", { history: enabled }).catch(() => {});\n\t\tvoid options.bridge\n\t\t\t.send(enabled ? \"VKWebAppEnableSwipeBack\" : \"VKWebAppDisableSwipeBack\")\n\t\t\t.catch(() => {});\n\t};\n\n\tsync();\n\tconst unsubscribe = options.history.subscribe(sync);\n\tconst manager = {\n\t\tsetOverride: (enabled: boolean | null): void => {\n\t\t\toverride = enabled;\n\t\t\tsync();\n\t\t},\n\t};\n\tactiveManager = manager;\n\treturn {\n\t\tsetOverride: manager.setOverride,\n\t\tdestroy: () => {\n\t\t\tunsubscribe();\n\t\t\tif (activeManager === manager) {\n\t\t\t\tactiveManager = null;\n\t\t\t}\n\t\t},\n\t};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,IAAI,gBAAuE;;AAG3E,SAAgB,qBAAqB,SAA+B;CACnE,eAAe,YAAY,OAAO;AACnC;AAeA,SAAgB,uBAAuB,SAIrC;CACD,IAAI,cAA8B;CAClC,IAAI,WAA2B;CAE/B,MAAM,aAAmB;EACxB,MAAM,QAAQ,QAAQ,QAAQ,SAAS,OAAO;EAC9C,MAAM,OAAO,UAAU,KAAA,IAAY,QAAQ,QAAQ;EACnD,MAAM,UAAU,QAAQ,YAAY,QAAQ,QAAS,YAAY;EACjE,IAAI,YAAY,aACf;EAED,cAAc;EACd,QAAa,OAAO,KAAK,4BAA4B,EAAE,SAAS,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;EACzF,QAAa,OACX,KAAK,UAAU,4BAA4B,0BAA0B,CAAC,CACtE,YAAY,CAAC,CAAC;CACjB;CAEA,KAAK;CACL,MAAM,cAAc,QAAQ,QAAQ,UAAU,IAAI;CAClD,MAAM,UAAU,EACf,cAAc,YAAkC;EAC/C,WAAW;EACX,KAAK;CACN,EACD;CACA,gBAAgB;CAChB,OAAO;EACN,aAAa,QAAQ;EACrB,eAAe;GACd,YAAY;GACZ,IAAI,kBAAkB,SACrB,gBAAgB;EAElB;CACD;AACD"}

package/dist/core/vk-history.d.ts

@@ -0,0 +1,41 @@
+//#region src/core/vk-history.d.ts
+/**
+ * VK history: the same trick TanStack's own hash history uses —
+ * `createBrowserHistory` with swapped `parseLocation`/`createHref` — so we
+ * inherit blockers with rollback, popstate classification, throttling and
+ * TSR index/key stamping.
+ *
+ * Modes (parity with the old router's three factories):
+ * - `"hash"` (default) → old `createHashRouter`: the hash IS the location
+ *   (`#/item/7?tab=x`).
+ * - `"hash-param"` → old `createHashParamRouter`: the whole router
+ *   location rides in one hash query param (`#?path=%2Fitem%2F7`), foreign
+ *   hash params (launch params, UTM) are preserved next to it, and the
+ *   real `location.search` is never touched.
+ *
+ * Deep links written by the OTHER mode resolve too (legacy tolerance).
+ * `"browser"` → pass TanStack's default history instead (omit `history`
+ * in createRouter) — old `createBrowserRouter`.
+ */
+export declare const DEFAULT_PATH_PARAM = "path";
+export type VkHistoryMode = "hash" | "hash-param";
+export interface VkHistoryOptions {
+  window?: Window;
+  /** Hash query param carrying the router location (hash-param mode). */
+  pathParam?: string;
+  /** URL mode. Default `"hash"`. */
+  mode?: VkHistoryMode;
+}
+/** The history plus the payload codecs the bridge sync layer needs. */
+export declare function createVkHistory(options?: VkHistoryOptions): {
+  history: import("@tanstack/history").RouterHistory;
+  /** Hash content for a router href — the SetLocation payload. */
+  serializePayload: (href: string) => string;
+  /** Router href from a SetLocation/ChangeFragment payload. */
+  parsePayload: (payload: string) => string;
+  /** Router href from the current document hash. */
+  parseCurrentHash: () => string;
+};
+export type VkHistory = ReturnType<typeof createVkHistory>;
+//#endregion
+//# sourceMappingURL=vk-history.d.ts.map

package/dist/core/vk-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vk-history.d.ts","names":[],"sources":["../../src/core/vk-history.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBA4Ba;YAED;iBAQK;EAChB,SAAS;;EAET;;EAEA,OAAO;;;wBAIQ,gBAAgB,UAAS;;;EAqDb,mBAAA;;EAED,eAAA;;;;YA2Cf,YAAY,kBAAkB"}