@absolutejs/absolute 0.20.0-beta.0 → 0.20.0-beta.2

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

@@ -0,0 +1,61 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+import { type AbsoluteMobileHost } from './emulatorDoctor';
+export declare const ABSOLUTE_IOS_RELEASE_FORMAT: 1;
+export type AbsoluteIosReleaseMetadata = {
+    appBuild: string;
+    appId: string;
+    artifact: 'App.ipa';
+    buildNumber?: number;
+    bytes: number;
+    engine: 'capacitor';
+    format: typeof ABSOLUTE_IOS_RELEASE_FORMAT;
+    marketingVersion: string;
+    platform: 'ios';
+    releaseId: string;
+    runtime: string;
+    sha256: string;
+    signed: boolean;
+    type: 'ipa';
+};
+type CommandOptions = {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+};
+type CommandResult = {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+};
+export type BuildAbsoluteIosReleaseOptions = {
+    allowUnsigned?: boolean;
+    capture?: (command: string[], options?: CommandOptions) => CommandResult;
+    config: NormalizedAbsoluteMobileConfig;
+    host?: AbsoluteMobileHost;
+    outputDirectory?: string;
+    prepareBuildNumber?: (buildIdentity: string) => Promise<number>;
+    projectRoot: string;
+    run?: (command: string[], options?: CommandOptions) => Promise<number>;
+    buildNumber?: number;
+};
+export declare const fingerprintAbsoluteIosNativeProject: (nativeDirectory: string) => Promise<string>;
+export declare const buildAbsoluteIosRelease: (options: BuildAbsoluteIosReleaseOptions) => Promise<{
+    artifactPath: string;
+    metadata: {
+        artifact: "App.ipa";
+        sha256: string;
+        type: "ipa";
+        format: typeof ABSOLUTE_IOS_RELEASE_FORMAT;
+        bytes: number;
+        runtime: string;
+        releaseId: string;
+        appBuild: string;
+        appId: string;
+        platform: "ios";
+        engine: "capacitor";
+        signed: boolean;
+        buildNumber?: number | undefined;
+        marketingVersion: string;
+    };
+    releaseRoot: string;
+}>;
+export {};

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

@@ -20,3 +20,17 @@ export declare const materializeAbsoluteMobileCompatibilityBundle: (input: Absol
     format: 1;
     releases: AbsoluteMobileCompatibilityArtifact[];
 }>;
+export declare const readAbsoluteMobileMaterializedReleases: (root: string) => Promise<{
+    artifact: {
+        releaseId: string;
+        pages: import("./releaseArtifact").AbsoluteMobileCompatibilityPage[];
+        routes: import("./releaseArtifact").AbsoluteMobileCompatibilityRoute[];
+        format: typeof import("./releaseArtifact").ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
+        runtime: string;
+        appBuild: string;
+        appId: string;
+        generation: number;
+        producer: import("./releaseArtifact").AbsoluteMobileCompatibilityProducer;
+    };
+    producer: Bun.BunFile;
+}[]>;

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

@@ -0,0 +1,5 @@
+import type { MobilePlatform } from '../../types/build';
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const applyAbsoluteNativeDeepLinks: (config: NormalizedAbsoluteMobileConfig, platforms?: readonly MobilePlatform[]) => Promise<{
+    changed: MobilePlatform[];
+}>;

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

@@ -3,6 +3,7 @@ export declare const ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT: 1;
 export declare const ABSOLUTE_MOBILE_RETAINED_GENERATIONS = 3;
 export type AbsoluteMobileCompatibilityPage = {
     bundleHash: string;
+    bundlePath: string;
     contract: string;
     framework: AbsoluteMobilePageFramework;
     pageId: string;

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

@@ -0,0 +1,13 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export type AbsoluteMobileReleaseCheck = {
+    detail: string;
+    id: string;
+    path?: string;
+    remediation?: string;
+    status: 'fail' | 'pass';
+};
+export type AbsoluteMobileReleaseDoctorResult = {
+    checks: AbsoluteMobileReleaseCheck[];
+    ready: boolean;
+};
+export declare const inspectAbsoluteMobileRelease: (config: NormalizedAbsoluteMobileConfig, projectRoot: string) => Promise<AbsoluteMobileReleaseDoctorResult>;

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

@@ -0,0 +1,130 @@
+import type { AbsoluteAndroidReleaseMetadata } from './androidRelease';
+import type { AbsoluteIosReleaseMetadata } from './iosRelease';
+export type AbsoluteGooglePlayReleaseTarget = {
+    changesNotSentForReview?: boolean;
+    inAppUpdatePriority?: number;
+    name?: string;
+    releaseNotes?: readonly {
+        language: string;
+        text: string;
+    }[];
+    reviewBehavior?: 'CANCEL_IN_REVIEW_AND_SUBMIT' | 'ERROR_IF_IN_REVIEW';
+    status?: 'completed' | 'draft' | 'halted' | 'inProgress';
+    track: string;
+    userFraction?: number;
+};
+export type AbsoluteAppStoreConnectReleaseTarget = {
+    groups?: readonly string[];
+    submitForReview?: boolean;
+    whatsNew?: readonly {
+        locale: string;
+        text: string;
+    }[];
+};
+export type AbsoluteNativeReleasePublication = {
+    channel?: {
+        channel: string;
+        releaseId: string;
+    };
+    record: {
+        metadata: AbsoluteAndroidReleaseMetadata | AbsoluteIosReleaseMetadata;
+    };
+    reused: boolean;
+    googlePlay?: {
+        receipt: {
+            intent: {
+                track: string;
+            };
+            packageName: string;
+            provider: 'google-play';
+            releaseId: string;
+            sha256: string;
+            stage: string;
+            versionCode?: string;
+        };
+        reused: boolean;
+    };
+    appStoreConnect?: {
+        receipt: {
+            appleAppId: string;
+            buildId?: string;
+            buildNumber: number;
+            intent: {
+                groups: string[];
+                submitForReview: boolean;
+            };
+            marketingVersion: string;
+            provider: 'app-store-connect';
+            releaseId: string;
+            sha256: string;
+            stage: string;
+        };
+        reused: boolean;
+    };
+};
+export type AbsoluteNativeReleasePublisher = {
+    prepareAndroidRelease?: (options: {
+        buildIdentity: string;
+        googlePlay?: AbsoluteGooglePlayReleaseTarget;
+        packageName: string;
+        signal?: AbortSignal;
+    }) => Promise<{
+        versionCode?: number;
+    }>;
+    prepareIosRelease?: (options: {
+        buildIdentity: string;
+        bundleId: string;
+        marketingVersion: string;
+        signal?: AbortSignal;
+    }) => Promise<{
+        buildNumber: number;
+    }>;
+    publish: (options: {
+        allowUnsigned?: boolean;
+        appStoreConnect?: AbsoluteAppStoreConnectReleaseTarget;
+        channel?: string;
+        googlePlay?: AbsoluteGooglePlayReleaseTarget;
+        releaseRoot: string;
+        signal?: AbortSignal;
+    }) => Promise<AbsoluteNativeReleasePublication>;
+};
+export declare const prepareAbsoluteIosRelease: (publisher: AbsoluteNativeReleasePublisher, options: {
+    buildIdentity: string;
+    bundleId: string;
+    marketingVersion: string;
+    signal?: AbortSignal;
+}) => Promise<number>;
+type PrepareAbsoluteAndroidReleaseOptions = {
+    buildIdentity: string;
+    googlePlay: AbsoluteGooglePlayReleaseTarget;
+    packageName: string;
+    signal?: AbortSignal;
+};
+export declare const prepareAbsoluteAndroidRelease: (publisher: AbsoluteNativeReleasePublisher, options: PrepareAbsoluteAndroidReleaseOptions) => Promise<number>;
+export type PublishAbsoluteAndroidReleaseOptions = {
+    allowUnsigned?: boolean;
+    channel?: string;
+    googlePlay?: AbsoluteGooglePlayReleaseTarget;
+    modulePath: string;
+    projectRoot: string;
+    release: {
+        metadata: AbsoluteAndroidReleaseMetadata;
+        releaseRoot: string;
+    };
+    signal?: AbortSignal;
+};
+export declare const loadAbsoluteNativeReleasePublisher: (projectRoot: string, requestedModulePath: string) => Promise<AbsoluteNativeReleasePublisher>;
+export declare const publishAbsoluteAndroidRelease: (options: PublishAbsoluteAndroidReleaseOptions) => Promise<AbsoluteNativeReleasePublication>;
+export declare const publishAbsoluteIosRelease: (options: {
+    allowUnsigned?: boolean;
+    appStoreConnect?: AbsoluteAppStoreConnectReleaseTarget;
+    channel?: string;
+    modulePath: string;
+    projectRoot: string;
+    release: {
+        metadata: AbsoluteIosReleaseMetadata;
+        releaseRoot: string;
+    };
+    signal?: AbortSignal;
+}) => Promise<AbsoluteNativeReleasePublication>;
+export {};

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

@@ -0,0 +1,3 @@
+import type { AbsoluteMobileCompatibilityRoute } from './releaseArtifact';
+export declare const matchesAbsoluteMobileRoutePattern: (pattern: string, pathname: string) => boolean;
+export declare const resolveAbsoluteMobileRoute: (routes: readonly AbsoluteMobileCompatibilityRoute[], pathname: string, method?: "GET" | "HEAD") => AbsoluteMobileCompatibilityRoute | undefined;

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

@@ -0,0 +1,13 @@
+import type { BunPlugin } from 'bun';
+import { type AbsoluteMobileBuildPageMetadata } from './buildMetadata';
+type MobileRouteTransformOptions = {
+    entry: string;
+    projectRoot?: string;
+};
+export declare const ABSOLUTE_MOBILE_TRANSFORM_PROTOCOL: 1;
+export declare const createAbsoluteMobileRouteMetadataPlugin: (options: MobileRouteTransformOptions) => BunPlugin;
+export declare const inspectAbsoluteMobileRouteMetadata: (options: MobileRouteTransformOptions) => {
+    file: string;
+    metadata: AbsoluteMobileBuildPageMetadata;
+}[];
+export {};

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

@@ -0,0 +1 @@
+export declare const startAbsoluteMobileShell: () => Promise<void>;

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

@@ -0,0 +1,31 @@
+import { type AbsoluteMobilePageActivationOptions } from './client';
+import type { AbsoluteMobileCompatibilityPage, AbsoluteMobileCompatibilityRoute } from './releaseArtifact';
+export declare const ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT: 1;
+export type AbsoluteMobileClientPage = AbsoluteMobileCompatibilityPage & {
+    localBundlePath: string;
+};
+export type AbsoluteMobileClientManifest = {
+    appBuild: string;
+    appId: string;
+    appName: string;
+    deepLinkHosts: string[];
+    deepLinkScheme?: string;
+    entry: string;
+    format: typeof ABSOLUTE_MOBILE_CLIENT_MANIFEST_FORMAT;
+    pages: AbsoluteMobileClientPage[];
+    productionOrigin: string;
+    routes: AbsoluteMobileCompatibilityRoute[];
+    runtime: string;
+};
+export type AbsoluteMobileTransportOptions = {
+    fetch?: typeof globalThis.fetch;
+    headers?: HeadersInit;
+};
+export declare const createAbsoluteMobilePageRequest: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Request;
+export declare const fetchAbsoluteMobilePage: (manifest: AbsoluteMobileClientManifest, path: string, options?: AbsoluteMobileTransportOptions) => Promise<unknown>;
+export declare const navigateAbsoluteMobilePage: (manifest: AbsoluteMobileClientManifest, path: string, options: AbsoluteMobileTransportOptions & AbsoluteMobilePageActivationOptions) => Promise<import("./pageProtocol").AbsoluteMobileUpgradeRequiredResult | {
+    contract: string;
+    kind: "rendered";
+    pageId: string;
+}>;
+export declare const resolveAbsoluteMobileDeepLink: (manifest: AbsoluteMobileClientManifest, value: string) => string;

package/dist/src/react/hooks/useMediaQuery.d.ts

@@ -1,5 +1,5 @@
 import { Breakpoint, Breakpoints } from '../../../types/mediaQuery';
-export declare const UserAgentProvider: import("react").Provider<"other" | "bot" | "phone" | "tablet" | "tv" | "console" | "car" | "iot" | "desktop" | null>;
+export declare const UserAgentProvider: import("react").Provider<"console" | "other" | "bot" | "phone" | "tablet" | "tv" | "car" | "iot" | "desktop" | null>;
 export declare const useMediaQuery: (customBreakpoints?: Breakpoints) => {
     breakpoint: string;
     isSizeOrGreater: (target: Breakpoint) => boolean;

package/dist/src/react/jsxDevRuntimeCompat.d.ts

@@ -1,4 +1,4 @@
-import { Fragment, jsx } from 'react/jsx-runtime';
+import { Fragment, jsx } from './jsxRuntimeCompat';
 type JSXType = Parameters<typeof jsx>[0];
 type JSXKey = Parameters<typeof jsx>[2];
 type JSXProps = Parameters<typeof jsx>[1] & {

package/dist/src/react/jsxRuntimeCompat.d.ts

@@ -0,0 +1,7 @@
+import { Fragment, jsx as reactJsx } from 'react/jsx-runtime';
+type JSXType = Parameters<typeof reactJsx>[0];
+type JSXProps = Parameters<typeof reactJsx>[1];
+type JSXKey = Parameters<typeof reactJsx>[2];
+export { Fragment };
+export declare const jsx: (type: JSXType, props: JSXProps, key?: JSXKey) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export declare const jsxs: (type: JSXType, props: JSXProps, key?: JSXKey) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;

package/dist/src/react/pageHandler.d.ts

@@ -1,4 +1,5 @@
 import type { ComponentType as ReactComponent } from 'react';
+import type { AbsoluteMobileBuildPageMetadata } from '../mobile/buildMetadata';
 import { type StreamingSlotEnhancerOptions } from '../core/responseEnhancers';
 type ReactPageRenderOptions = StreamingSlotEnhancerOptions & {
     collectStreamingSlots?: boolean;
@@ -9,6 +10,8 @@ type ReactPageRenderOptions = StreamingSlotEnhancerOptions & {
     bufferStreamForEtag?: boolean;
 };
 export type ReactPageRequestInput<Props extends Record<string, unknown> = Record<never, never>> = ReactPageRenderOptions & {
+    /** @internal Build-generated mobile identity. Application code must not set this. */
+    __absoluteMobile?: AbsoluteMobileBuildPageMetadata;
     Page: ReactComponent<Props>;
     index: string;
     /** The incoming Elysia request. When provided, the request's pathname

package/dist/src/utils/loadConfig.d.ts

@@ -20,6 +20,7 @@ export declare const loadConfig: (configPath?: string) => Promise<{
     emberDirectory?: string;
     htmlDirectory?: string;
     htmxDirectory?: string;
+    mobile?: import("..").MobileConfig;
     stylesConfig?: string | import("..").StylesConfig;
     stylePreprocessors?: import("..").StylePreprocessorConfig;
     postcss?: import("..").PostCSSConfig;

package/dist/src/utils/logger.d.ts

@@ -3,6 +3,7 @@
  * Provides formatted output with ANSI colors and timestamps
  */
 import { formatTimestamp } from './startupBanner';
+import type { HMRApplyKind, HMRApplyOutcome, HMRClientTarget } from '../../types/messages';
 export { formatTimestamp };
 /**
  * Startup banner
@@ -30,6 +31,7 @@ export declare const logError: (message: string, error?: Error | string) => void
  * HMR update message
  * Format: "10:30:45 AM [hmr] hmr update /pages/App.tsx"
  */
+export declare const logHmrClientUpdate: (path: string, framework: string | undefined, duration: number, target: HMRClientTarget, serverMs?: number, clientMs?: number, outcome?: HMRApplyOutcome, kind?: HMRApplyKind) => void;
 export declare const logHmrUpdate: (path: string, framework?: string, duration?: number) => void;
 /**
  * Generic info message

package/dist/src/utils/userAgentFunctions.d.ts

@@ -1 +1 @@
-export declare const getUserAgentType: (userAgent: string) => "other" | "bot" | "phone" | "tablet" | "tv" | "console" | "car" | "iot" | "desktop";
+export declare const getUserAgentType: (userAgent: string) => "console" | "other" | "bot" | "phone" | "tablet" | "tv" | "car" | "iot" | "desktop";

package/dist/svelte/index.js

@@ -1976,6 +1976,19 @@ var colors2, frameworkColors, formatPath = (filePath) => {
   const errorMsg = error instanceof Error ? error.message : error;
   const fullMessage = `${colors2.red}error${colors2.reset} ${message}${errorMsg ? `: ${errorMsg}` : ""}`;
   console.error(`${timestamp} ${tag} ${fullMessage}`);
+}, logHmrClientUpdate = (path, framework, duration, target, serverMs, clientMs, outcome = "applied", kind) => {
+  const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
+  const targetLabel = target.startsWith("capacitor-") ? target.slice("capacitor-".length) : target;
+  const tag = `${colors2.cyan}[hmr:${targetLabel}]${colors2.reset}`;
+  const pathColor = framework ? getFrameworkColor(framework) : colors2.white;
+  const breakdown = serverMs === undefined || clientMs === undefined ? "" : `; server ${serverMs}ms, client ${clientMs}ms`;
+  let action = "failed after";
+  if (outcome === "applied")
+    action = "applied in";
+  else if (outcome === "reloaded")
+    action = "falling back to reload after";
+  const kindLabel = kind ? `${kind} ` : "";
+  console.log(`${timestamp} ${tag} ${framework ?? "update"} ${kindLabel}${pathColor}${formatPath(path)}${colors2.reset} ${colors2.dim}${action} ${duration}ms${breakdown}${colors2.reset}`);
 }, logHmrUpdate = (path, framework, duration) => {
   log("hmr update", { duration, framework, path });
 }, logInfo = (message) => {
@@ -4726,5 +4739,5 @@ export {
   createTypedIsland
 };
 
-//# debugId=58FB2DF95ACA563C64756E2164756E21
+//# debugId=8B013C6A3D2007D964756E2164756E21
 //# sourceMappingURL=index.js.map