@absolutejs/absolute 0.20.0-beta.30 → 0.20.0-beta.31

package/dist/mobile/shellBootstrap.js

@@ -433,6 +433,210 @@ var installAbsoluteMobileStaticDocument = async (manifest, page, localUrl) => {
   await ready;
 };
 
+// node_modules/@absolutejs/http/dist/index.js
+class AbsoluteHttpError extends Error {
+  code;
+  cause;
+  status;
+  url;
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "AbsoluteHttpError";
+    this.code = code;
+    this.cause = options.cause;
+    this.status = options.status;
+    this.url = options.url;
+  }
+}
+var loopbackHosts = new Set(["127.0.0.1", "[::1]", "localhost"]);
+var normalizeAbsoluteHttpOrigin = (value) => {
+  let url;
+  try {
+    url = new URL(value);
+  } catch (cause) {
+    throw new AbsoluteHttpError("origin", "HTTP origin is invalid.", {
+      cause
+    });
+  }
+  const loopback = url.protocol === "http:" && loopbackHosts.has(url.hostname);
+  if (url.protocol !== "https:" && !loopback)
+    throw new AbsoluteHttpError("origin", "HTTP origin must use HTTPS outside loopback development.");
+  if (url.username || url.password || url.pathname !== "/" || url.search || url.hash)
+    throw new AbsoluteHttpError("origin", "HTTP origin cannot contain credentials, a path, query, or fragment.");
+  return url.origin;
+};
+var resolveAbsoluteHttpUrl = (target, origin) => {
+  let url;
+  try {
+    url = new URL(String(target), `${origin}/`);
+  } catch (cause) {
+    throw new AbsoluteHttpError("origin", "HTTP request URL is invalid.", {
+      cause
+    });
+  }
+  if (url.username || url.password)
+    throw new AbsoluteHttpError("origin", "HTTP request URLs cannot contain credentials.");
+  if (url.origin !== origin)
+    throw new AbsoluteHttpError("origin", "Absolute HTTP refused a request outside the configured application origin.", { url: url.href });
+  url.hash = "";
+  return url;
+};
+var createAbsoluteHttpTransport = ({
+  fetch: fetchImpl = globalThis.fetch,
+  origin,
+  runtime
+}) => ({
+  fetch: fetchImpl,
+  origin: normalizeAbsoluteHttpOrigin(origin),
+  runtime
+});
+var createWebHttpTransport = (options = {}) => {
+  const origin = options.origin ?? globalThis.location?.origin;
+  if (!origin)
+    throw new TypeError("The web HTTP transport requires a browser origin or explicit origin.");
+  return createAbsoluteHttpTransport({
+    ...options.fetch ? { fetch: options.fetch } : {},
+    origin,
+    runtime: "web"
+  });
+};
+var RUNTIME_REGISTRY = Symbol.for("@absolutejs/http/runtime");
+var registryHost = globalThis;
+var isRuntimeRegistry = (value) => typeof value === "object" && value !== null && Array.isArray(Reflect.get(value, "installations"));
+var runtimeRegistry = (() => {
+  const existing = registryHost[RUNTIME_REGISTRY];
+  if (isRuntimeRegistry(existing))
+    return existing;
+  const created = { installations: [] };
+  Object.defineProperty(registryHost, RUNTIME_REGISTRY, {
+    configurable: false,
+    enumerable: false,
+    value: created,
+    writable: false
+  });
+  return created;
+})();
+var fallbackTransport = () => {
+  if (typeof location !== "undefined" && location.origin)
+    return createWebHttpTransport();
+  throw new AbsoluteHttpError("not-configured", "Absolute HTTP requires a request-scoped SSR transport outside a browser.");
+};
+var getAbsoluteHttpTransport = () => runtimeRegistry.installations.at(-1)?.transport ?? (runtimeRegistry.fallback ??= fallbackTransport());
+var installAbsoluteHttpTransport = (transport) => {
+  const installation = { transport };
+  runtimeRegistry.installations.push(installation);
+  return () => {
+    const index = runtimeRegistry.installations.indexOf(installation);
+    if (index >= 0)
+      runtimeRegistry.installations.splice(index, 1);
+  };
+};
+var forbiddenCredentialHeaders = new Set([
+  "authorization",
+  "cookie",
+  "proxy-authorization"
+]);
+var transportFor = (configured) => configured ?? getAbsoluteHttpTransport();
+var safeHeaders = (input) => {
+  const headers = new Headers(input);
+  for (const name of forbiddenCredentialHeaders) {
+    if (headers.has(name))
+      throw new AbsoluteHttpError("origin", `Absolute HTTP owns the ${name} credential header for trusted transports.`);
+  }
+  return headers;
+};
+var requestFor = (target, options, transport) => {
+  const source = target instanceof Request ? target : undefined;
+  const requestedUrl = source ? source.url : target;
+  const url = resolveAbsoluteHttpUrl(requestedUrl, transport.origin);
+  const headers = safeHeaders(options?.headers ?? source?.headers);
+  return new Request(source ?? url, {
+    ...options,
+    credentials: transport.runtime === "web" ? "same-origin" : "omit",
+    headers,
+    redirect: "error"
+  });
+};
+var normalizeFetchError = (caught, url) => {
+  if (caught instanceof AbsoluteHttpError)
+    return caught;
+  if (caught instanceof DOMException && (caught.name === "AbortError" || caught.name === "TimeoutError"))
+    return new AbsoluteHttpError("aborted", "HTTP request was aborted.", {
+      cause: caught,
+      url
+    });
+  return new AbsoluteHttpError("network", "HTTP request failed.", {
+    cause: caught,
+    url
+  });
+};
+var requireOk = (response) => {
+  if (!response.ok)
+    throw new AbsoluteHttpError("http", `HTTP request failed with status ${response.status}.`, { status: response.status, url: response.url });
+  return response;
+};
+var parseJson = async (response) => {
+  const text = await response.text();
+  if (text === "")
+    return;
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new AbsoluteHttpError("response", "HTTP response is not valid JSON.", {
+      cause,
+      status: response.status,
+      url: response.url
+    });
+  }
+};
+var jsonOptions = (method, body, options) => {
+  const headers = new Headers(options?.headers);
+  if (body !== undefined && !headers.has("content-type"))
+    headers.set("content-type", "application/json");
+  let encoded;
+  try {
+    encoded = body === undefined ? undefined : JSON.stringify(body);
+  } catch (cause) {
+    throw new AbsoluteHttpError("body", "HTTP body is not JSON serializable.", {
+      cause
+    });
+  }
+  return encoded === undefined ? { ...options, headers, method } : { ...options, body: encoded, headers, method };
+};
+var createAbsoluteHttpClient = (options = {}) => {
+  const fetchTrusted = async (input, init) => {
+    const transport = transportFor(options.transport);
+    const request2 = requestFor(input, init, transport);
+    try {
+      return await transport.fetch(request2);
+    } catch (caught) {
+      throw normalizeFetchError(caught, request2.url);
+    }
+  };
+  const request = (target, requestOptions) => fetchTrusted(target, requestOptions);
+  const json = async (target, requestOptions) => parseJson(requireOk(await request(target, requestOptions)));
+  const jsonMethod = (method, target, body, requestOptions) => json(target, jsonOptions(method, body, requestOptions));
+  return {
+    delete: (target, requestOptions) => {
+      const { body, ...optionsWithoutBody } = requestOptions ?? {};
+      return jsonMethod("DELETE", target, body, optionsWithoutBody);
+    },
+    fetch: fetchTrusted,
+    get: (target, requestOptions) => json(target, { ...requestOptions, method: "GET" }),
+    json,
+    origin: () => transportFor(options.transport).origin,
+    patch: (target, body, requestOptions) => jsonMethod("PATCH", target, body, requestOptions),
+    post: (target, body, requestOptions) => jsonMethod("POST", target, body, requestOptions),
+    put: (target, body, requestOptions) => jsonMethod("PUT", target, body, requestOptions),
+    request,
+    text: async (target, requestOptions) => requireOk(await request(target, requestOptions)).text()
+  };
+};
+var http = createAbsoluteHttpClient();
+
+// src/mobile/shellHttp.ts
+var installAbsoluteMobileShellHttp = (origin, fetch2 = globalThis.fetch) => installAbsoluteHttpTransport(createAbsoluteHttpTransport({ fetch: fetch2, origin, runtime: "native" }));
+
 // src/mobile/shellBootstrap.ts
 var MANIFEST_PATH = "./absolute-mobile-manifest.json";
 var STATUS_ID = "absolute-mobile-status";
@@ -574,6 +778,7 @@ var startAbsoluteMobileShell = async (options = {}) => {
   const auth = manifest.auth && options.createAuth ? await options.createAuth(manifest.auth, {
     beforeSignOut: options.beforeSignOut
   }) : undefined;
+  installAbsoluteMobileShellHttp(manifest.productionOrigin, auth?.fetch ?? globalThis.fetch);
   if (auth)
     options.connectPush?.(auth);
   if (auth && manifest.sync?.socketTickets)

package/dist/src/mobile/index.d.ts

@@ -28,4 +28,5 @@ export * from './releaseArtifact';
 export * from './releasePublisher';
 export * from './routeMetadataTransform';
 export * from './routeMatcher';
+export * from './shellHttp';
 export * from './transport';

package/dist/src/mobile/shellHttp.d.ts

@@ -0,0 +1,2 @@
+import { type AbsoluteHttpFetch } from '@absolutejs/http';
+export declare const installAbsoluteMobileShellHttp: (origin: string, fetch?: AbsoluteHttpFetch) => () => void;

package/package.json

@@ -10,6 +10,7 @@
 		"@absolutejs/auth": "0.75.0",
 		"@absolutejs/devices": "0.7.0",
 		"@absolutejs/devices-capacitor": "0.8.0",
+		"@absolutejs/http": "0.0.1",
 		"@absolutejs/pwa": "0.14.0",
 		"@capacitor/browser": "8.0.4",
 		"@capacitor/keyboard": "8.0.5",
@@ -503,7 +504,7 @@
 			]
 		}
 	},
-	"version": "0.20.0-beta.30",
+	"version": "0.20.0-beta.31",
 	"workspaces": [
 		"tests/fixtures/*",
 		"tests/fixtures/_packages/*"