@oatscenter/trellis-svelte 0.100.0-rc.1

package/dist/device_activation_controller.d.ts

@@ -0,0 +1,91 @@
+import type { AsyncResult, BaseError } from "@oatscenter/result";
+import type { OperationEvent, TerminalOperation } from "@oatscenter/trellis";
+import type { DeviceUserAuthoritiesResolveOutput, DeviceUserAuthoritiesResolveProgress } from "@oatscenter/trellis/auth";
+import { type DeviceActivationView } from "./internal/activation_view.js";
+import { type StorageLike } from "./internal/callback_state.js";
+import { type DeviceActivationConnectAuthUrlState } from "./internal/portal_url.js";
+export type DeviceActivationSignInOptions = {
+    redirectTo?: string;
+    landingPath?: string;
+    context?: unknown;
+};
+export type DeviceActivationBindResult = {
+    status: "bound";
+} | {
+    status: "approval_denied";
+} | {
+    status: "approval_required";
+} | {
+    status: "insufficient_capabilities";
+    missingCapabilities: string[];
+} | {
+    status: "error";
+    message: string;
+};
+export type DeviceActivationAuth = {
+    init(): Promise<unknown>;
+    handleCallback(callbackUrl: string): Promise<DeviceActivationBindResult | null>;
+    signIn(options?: DeviceActivationSignInOptions): Promise<void>;
+};
+export type DeviceActivationControllerConfig = {
+    authState: DeviceActivationAuth;
+    createClient(authUrlState: DeviceActivationConnectAuthUrlState): Promise<DeviceActivationClient>;
+    getUrl?: () => URL;
+    replaceUrl?: (url: string) => void;
+    sessionStorage?: StorageLike;
+    createCallbackToken?: () => string;
+};
+export type DeviceActivationOperationRef = {
+    watch(): AsyncResult<AsyncIterable<OperationEvent<DeviceUserAuthoritiesResolveProgress, DeviceUserAuthoritiesResolveOutput>>, BaseError>;
+    wait(): AsyncResult<TerminalOperation<DeviceUserAuthoritiesResolveProgress, DeviceUserAuthoritiesResolveOutput>, BaseError>;
+};
+type CompanionConsent = NonNullable<DeviceUserAuthoritiesResolveProgress["companionConsent"]>;
+export type DeviceCompanionApproval = {
+    mode: "capabilities";
+    installedRevision: CompanionConsent["installedRevision"];
+    expectedGrantRevision: CompanionConsent["expectedGrantRevision"];
+    decisionDigest: CompanionConsent["decisionDigest"];
+    approvedCapabilities: Array<{
+        id: CompanionConsent["capabilities"][number]["id"];
+        consentDigest: CompanionConsent["capabilities"][number]["consentDigest"];
+    }>;
+    approvedResources: Array<{
+        kind: CompanionConsent["resources"][number]["kind"];
+        name: CompanionConsent["resources"][number]["name"];
+        commitment: CompanionConsent["resources"][number]["requestedCommitment"];
+    }>;
+    companionApproved: boolean;
+};
+export type DeviceActivationClient = {
+    activateDevice(input: {
+        flowId: string;
+        confirmationCode: string;
+        companionApproval?: DeviceCompanionApproval;
+    }): Promise<DeviceActivationOperationRef>;
+};
+export type DeviceActivationState = {
+    loading: boolean;
+    requestPending: boolean;
+    authError: string | null;
+    view: DeviceActivationView | null;
+    flowId: string | null;
+    confirmationCode: string;
+};
+export declare function createInitialDeviceActivationState(): DeviceActivationState;
+export declare class DeviceActivationControllerCore {
+    #private;
+    protected readonly state: DeviceActivationState;
+    constructor(config: DeviceActivationControllerConfig, state?: DeviceActivationState);
+    get loading(): boolean;
+    get requestPending(): boolean;
+    get authError(): string | null;
+    get view(): DeviceActivationView | null;
+    get flowId(): string | null;
+    get confirmationCode(): string;
+    set confirmationCode(value: string);
+    load(): Promise<void>;
+    stop(): void;
+    signIn(): Promise<void>;
+    requestActivation(): Promise<void>;
+}
+export {};

package/dist/device_activation_controller.js

@@ -0,0 +1,318 @@
+import { ulid } from "ulid";
+import { createDeviceActivationReadyView, createDeviceActivationSignInRequiredView, createInvalidDeviceActivationView, isDeviceActivationReviewerRequiredFailure, mapDeviceActivationFailure, mapDeviceActivationProgress, mapDeviceActivationTerminal, } from "./internal/activation_view.js";
+import { clearPreservedDeviceActivationCallbackState, getPreservedDeviceActivationCallbackState, preserveDeviceActivationCallbackState, } from "./internal/callback_state.js";
+import { buildDeviceActivationCallbackPath, buildDeviceActivationConnectAuthUrlState, cleanupDeviceActivationCallbackUrl, resolveDeviceActivationUrlState, } from "./internal/portal_url.js";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function buildCompanionApproval(consent) {
+    return {
+        mode: "capabilities",
+        installedRevision: consent.installedRevision,
+        expectedGrantRevision: consent.expectedGrantRevision,
+        decisionDigest: consent.decisionDigest,
+        approvedCapabilities: consent.capabilities
+            .filter((item) => item.required && item.eligible)
+            .map((item) => ({ id: item.id, consentDigest: item.consentDigest })),
+        approvedResources: consent.resources
+            .filter((item) => item.required && item.eligible)
+            .map((item) => ({
+            kind: item.kind,
+            name: item.name,
+            commitment: item.requestedCommitment,
+        })),
+        companionApproved: false,
+    };
+}
+function redirectErrorMessage(error) {
+    const message = errorMessage(error);
+    return message.startsWith("Redirecting to auth for provider selection")
+        ? null
+        : message;
+}
+function bindErrorMessage(result) {
+    if (result.status === "bound")
+        return null;
+    if (result.status === "approval_denied")
+        return "Portal access was denied.";
+    if (result.status === "approval_required") {
+        return "Approval is still pending.";
+    }
+    if (result.status === "insufficient_capabilities") {
+        return `Missing capabilities: ${result.missingCapabilities.join(", ")}`;
+    }
+    return result.message;
+}
+function defaultGetUrl() {
+    return new URL(globalThis.location.href);
+}
+function defaultReplaceUrl(url) {
+    globalThis.history.replaceState(globalThis.history.state, "", url);
+}
+function defaultCreateCallbackToken() {
+    return ulid();
+}
+export function createInitialDeviceActivationState() {
+    return {
+        loading: true,
+        requestPending: false,
+        authError: null,
+        view: null,
+        flowId: null,
+        confirmationCode: "",
+    };
+}
+export class DeviceActivationControllerCore {
+    state;
+    #authState;
+    #createClient;
+    #getUrl;
+    #replaceUrl;
+    #sessionStorage;
+    #createCallbackToken;
+    #client = null;
+    #observationRunId = 0;
+    constructor(config, state = createInitialDeviceActivationState()) {
+        this.state = state;
+        this.#authState = config.authState;
+        this.#createClient = config.createClient;
+        this.#getUrl = config.getUrl ?? defaultGetUrl;
+        this.#replaceUrl = config.replaceUrl ?? defaultReplaceUrl;
+        this.#sessionStorage = config.sessionStorage ?? null;
+        this.#createCallbackToken = config.createCallbackToken ??
+            defaultCreateCallbackToken;
+    }
+    get loading() {
+        return this.state.loading;
+    }
+    get requestPending() {
+        return this.state.requestPending;
+    }
+    get authError() {
+        return this.state.authError;
+    }
+    get view() {
+        return this.state.view;
+    }
+    get flowId() {
+        return this.state.flowId;
+    }
+    get confirmationCode() {
+        return this.state.confirmationCode;
+    }
+    set confirmationCode(value) {
+        this.state.confirmationCode = value;
+    }
+    async load() {
+        this.stop();
+        this.state.loading = true;
+        this.state.authError = null;
+        this.state.view = null;
+        this.#client = null;
+        const currentUrl = this.#getUrl();
+        let clientUrl = currentUrl;
+        const preservedState = this.#sessionStorage
+            ? getPreservedDeviceActivationCallbackState(this.#sessionStorage)
+            : null;
+        const { flowId, isAuthCallback } = resolveDeviceActivationUrlState(currentUrl, preservedState);
+        this.state.flowId = flowId;
+        if (!flowId) {
+            this.state.view = createInvalidDeviceActivationView("Missing flow id.");
+            this.state.loading = false;
+            return;
+        }
+        try {
+            await this.#authState.init();
+            if (isAuthCallback) {
+                const bindResult = await this.#authState.handleCallback(currentUrl.toString());
+                const cleanedUrl = cleanupDeviceActivationCallbackUrl(currentUrl, flowId);
+                if (cleanedUrl) {
+                    this.#replaceUrl(cleanedUrl);
+                    clientUrl = new URL(cleanedUrl, currentUrl.origin);
+                }
+                if (this.#sessionStorage) {
+                    clearPreservedDeviceActivationCallbackState(this.#sessionStorage);
+                }
+                const callbackAuthError = currentUrl.searchParams.get("authError");
+                if (callbackAuthError && !bindResult) {
+                    this.state.authError = callbackAuthError;
+                    this.state.view = createDeviceActivationSignInRequiredView(flowId);
+                    return;
+                }
+                if (bindResult) {
+                    const bindError = bindErrorMessage(bindResult);
+                    if (bindError) {
+                        this.state.authError = bindError;
+                        this.state.view = createDeviceActivationSignInRequiredView(flowId);
+                        return;
+                    }
+                }
+            }
+            try {
+                this.#client = await this.#createClient(buildDeviceActivationConnectAuthUrlState(clientUrl));
+                this.state.view = createDeviceActivationReadyView(flowId);
+            }
+            catch (error) {
+                this.#client = null;
+                if (isAuthCallback) {
+                    this.state.authError = errorMessage(error);
+                }
+                this.state.view = createDeviceActivationSignInRequiredView(flowId);
+                if (!isAuthCallback) {
+                    await this.signIn();
+                }
+            }
+        }
+        catch (error) {
+            this.state.authError = errorMessage(error);
+            this.state.view = createDeviceActivationSignInRequiredView(flowId);
+        }
+        finally {
+            this.state.loading = false;
+        }
+    }
+    stop() {
+        this.#observationRunId += 1;
+    }
+    async signIn() {
+        this.state.authError = null;
+        if (!this.state.flowId || !this.#sessionStorage)
+            return;
+        const callbackToken = this.#createCallbackToken();
+        preserveDeviceActivationCallbackState(this.#sessionStorage, {
+            flowId: this.state.flowId,
+            callbackToken,
+        });
+        try {
+            await this.#authState.signIn({
+                redirectTo: buildDeviceActivationCallbackPath(this.#getUrl(), callbackToken),
+            });
+        }
+        catch (error) {
+            const message = redirectErrorMessage(error);
+            if (message) {
+                this.state.authError = message;
+            }
+        }
+    }
+    async requestActivation() {
+        const flowId = this.state.flowId;
+        const confirmationCode = this.state.confirmationCode.trim();
+        if (!flowId || !confirmationCode || !this.#client)
+            return;
+        this.stop();
+        const runId = this.#observationRunId;
+        this.state.requestPending = true;
+        this.state.authError = null;
+        try {
+            let operation = await this.#client.activateDevice({
+                flowId,
+                confirmationCode,
+            });
+            if (hasOperationSnapshot(operation)) {
+                let snapshot = await operation.get().match({
+                    ok: (value) => value,
+                    err: () => null,
+                });
+                for (let attempt = 0; attempt < 40 &&
+                    !snapshot?.progress?.companionConsent &&
+                    snapshot?.state === "running" &&
+                    this.#isRunActive(runId); attempt++) {
+                    await new Promise((resolve) => setTimeout(resolve, 250));
+                    snapshot = await operation.get().match({
+                        ok: (value) => value,
+                        err: () => null,
+                    });
+                }
+                if (snapshot?.progress && this.#isRunActive(runId)) {
+                    this.state.view = mapDeviceActivationProgress(flowId, snapshot.progress);
+                }
+                const companionConsent = snapshot?.progress?.companionConsent;
+                if (companionConsent && this.#isRunActive(runId)) {
+                    try {
+                        operation = await this.#client.activateDevice({
+                            flowId,
+                            confirmationCode,
+                            companionApproval: buildCompanionApproval(companionConsent),
+                        });
+                    }
+                    catch (error) {
+                        // Only a permission outcome means a reviewer must decide later;
+                        // malformed, stale, or transport failures stay visible/retryable.
+                        if (!isDeviceActivationReviewerRequiredFailure(error)) {
+                            throw error;
+                        }
+                    }
+                }
+            }
+            const watch = await operation.watch().match({
+                ok: (value) => value,
+                err: () => null,
+            });
+            const watchPromise = watch
+                ? this.#observeWatch(flowId, watch, runId)
+                : Promise.resolve(false);
+            const terminal = await operation.wait().orThrow();
+            const handledByWatch = await watchPromise;
+            if (!handledByWatch && this.#isRunActive(runId)) {
+                this.#applyTerminal(flowId, terminal);
+            }
+        }
+        catch (error) {
+            if (!this.#isRunActive(runId))
+                return;
+            const nextView = mapDeviceActivationFailure(flowId, error);
+            if (nextView) {
+                this.state.view = nextView;
+            }
+            else {
+                this.state.view = createDeviceActivationReadyView(flowId);
+                this.state.authError = errorMessage(error);
+            }
+        }
+        finally {
+            if (this.#isRunActive(runId)) {
+                this.state.requestPending = false;
+            }
+        }
+    }
+    #isRunActive(runId) {
+        return this.#observationRunId === runId;
+    }
+    #applyTerminal(flowId, terminal) {
+        const view = mapDeviceActivationTerminal(flowId, terminal);
+        if (view) {
+            this.state.view = view;
+            return;
+        }
+        this.state.view = createDeviceActivationReadyView(flowId);
+        if (terminal.error?.message) {
+            this.state.authError = terminal.error.message;
+        }
+    }
+    async #observeWatch(flowId, watch, runId) {
+        const iterator = watch[Symbol.asyncIterator]();
+        while (true) {
+            const next = await iterator.next();
+            if (next.done) {
+                return false;
+            }
+            const event = next.value;
+            if (!this.#isRunActive(runId)) {
+                await iterator.return?.();
+                return false;
+            }
+            if (event.type === "completed" || event.type === "failed" ||
+                event.type === "cancelled") {
+                this.#applyTerminal(flowId, event.snapshot);
+                return true;
+            }
+            if (event.type === "progress") {
+                this.state.view = mapDeviceActivationProgress(flowId, event.progress);
+            }
+        }
+    }
+}
+function hasOperationSnapshot(operation) {
+    return "get" in operation && typeof operation.get === "function";
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { default as TrellisProvider } from "./components/TrellisProvider.svelte";
+export type { TrellisProviderProps } from "./components/TrellisProvider.types.js";
+export type { CreateTrellisAppOptions, SvelteTrellisConnection, TrellisApp, TrellisAppOwner, TrellisAppUrl, TrellisAppUrlResolver, TrellisClientFor, TrellisContextClient, TrellisParticipantLike, } from "./context.js";
+export { createTrellisApp, resolveTrellisAppUrl } from "./context.js";
+export { AuthorizationContextController, type AuthorizationContextStatus, } from "./authorization_context.js";
+export { createDeviceActivationController, type DeviceActivationAuth, type DeviceActivationClient, DeviceActivationController, type DeviceActivationControllerConfig, type DeviceActivationOperationRef, } from "./device_activation.js";
+export { createPortalFlow, type CreatePortalFlowConfig, PortalFlowController, } from "./portal_flow.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { default as TrellisProvider } from "./components/TrellisProvider.svelte";
+export { createTrellisApp, resolveTrellisAppUrl } from "./context.js";
+export { AuthorizationContextController, } from "./authorization_context.js";
+export { createDeviceActivationController, DeviceActivationController, } from "./device_activation.js";
+export { createPortalFlow, PortalFlowController, } from "./portal_flow.js";

package/dist/internal/activation_view.d.ts

@@ -0,0 +1,44 @@
+import type { DeviceUserAuthoritiesResolveOutput, DeviceUserAuthoritiesResolveProgress } from "@oatscenter/trellis/auth";
+import type { TerminalOperation } from "@oatscenter/trellis";
+export type DeviceActivationView = {
+    mode: "sign_in_required";
+    flowId: string;
+} | {
+    mode: "ready";
+    flowId: string;
+} | {
+    mode: "pending_review";
+    flowId: string;
+    state: DeviceUserAuthoritiesResolveProgress["state"];
+} | {
+    mode: "activated";
+    flowId: string;
+    instanceId: string;
+    deploymentId: string;
+    activatedAt: string;
+} | {
+    mode: "rejected";
+    flowId: string;
+    reason?: string;
+} | {
+    mode: "expired";
+    flowId: string;
+    reason: string;
+} | {
+    mode: "invalid_flow";
+    reason: string;
+    flowId?: string;
+};
+/**
+ * Whether a companion resubmission failed because the signed-in user is not
+ * allowed to decide it, which leaves the activation to a reviewer. Malformed,
+ * stale, and transport failures are not reviewer outcomes.
+ */
+export declare function isDeviceActivationReviewerRequiredFailure(error: unknown): boolean;
+export declare function createDeviceActivationReadyView(flowId: string): DeviceActivationView;
+export declare function createDeviceActivationSignInRequiredView(flowId: string): DeviceActivationView;
+export declare function createInvalidDeviceActivationView(reason: string, flowId?: string): DeviceActivationView;
+export declare function mapDeviceActivationOutput(flowId: string, result: DeviceUserAuthoritiesResolveOutput): DeviceActivationView;
+export declare function mapDeviceActivationProgress(flowId: string, progress: DeviceUserAuthoritiesResolveProgress): DeviceActivationView;
+export declare function mapDeviceActivationFailure(flowId: string, error: unknown): DeviceActivationView | null;
+export declare function mapDeviceActivationTerminal(flowId: string, terminal: TerminalOperation<unknown, DeviceUserAuthoritiesResolveOutput>): DeviceActivationView | null;

package/dist/internal/activation_view.js

@@ -0,0 +1,95 @@
+function isoString(value) {
+    return value instanceof Date
+        ? value.toISOString()
+        : typeof value === "number" || typeof value === "bigint"
+            ? new Date(Number(value)).toISOString()
+            : value;
+}
+function errorReason(error) {
+    if (typeof error !== "object" || error === null || !("reason" in error)) {
+        return undefined;
+    }
+    const reason = Reflect.get(error, "reason");
+    return typeof reason === "string" ? reason : undefined;
+}
+/**
+ * Whether a companion resubmission failed because the signed-in user is not
+ * allowed to decide it, which leaves the activation to a reviewer. Malformed,
+ * stale, and transport failures are not reviewer outcomes.
+ */
+export function isDeviceActivationReviewerRequiredFailure(error) {
+    const reason = errorReason(error);
+    return (reason === "not_authorized" ||
+        reason === "insufficient_permissions" ||
+        reason === "forbidden");
+}
+export function createDeviceActivationReadyView(flowId) {
+    return { mode: "ready", flowId };
+}
+export function createDeviceActivationSignInRequiredView(flowId) {
+    return { mode: "sign_in_required", flowId };
+}
+export function createInvalidDeviceActivationView(reason, flowId) {
+    return flowId
+        ? { mode: "invalid_flow", reason, flowId }
+        : { mode: "invalid_flow", reason };
+}
+export function mapDeviceActivationOutput(flowId, result) {
+    if (result.review.state === "approved") {
+        return {
+            mode: "activated",
+            flowId,
+            instanceId: result.device.instanceId,
+            deploymentId: result.device.deploymentId,
+            activatedAt: isoString(result.review.decidedAt ?? result.device.updatedAt),
+        };
+    }
+    return {
+        mode: "rejected",
+        flowId,
+        ...(result.review.reason ? { reason: result.review.reason } : {}),
+    };
+}
+export function mapDeviceActivationProgress(flowId, progress) {
+    return {
+        mode: "pending_review",
+        flowId,
+        state: progress.state,
+    };
+}
+export function mapDeviceActivationFailure(flowId, error) {
+    const reason = errorReason(error);
+    if (reason === "device_activation_flow_not_found") {
+        return createInvalidDeviceActivationView("This activation link is no longer valid.", flowId);
+    }
+    if (reason === "device_activation_flow_expired") {
+        return {
+            mode: "expired",
+            flowId,
+            reason: "The activation request expired. Start again from the auth service.",
+        };
+    }
+    if (reason === "unknown_device") {
+        return createInvalidDeviceActivationView("This activation link no longer matches a known device.", flowId);
+    }
+    if (reason === "device_deployment_not_found") {
+        return createInvalidDeviceActivationView("This device deployment is no longer available.", flowId);
+    }
+    if (reason === "invalid_request") {
+        return createInvalidDeviceActivationView("Trellis rejected this activation request. Start again from the device.", flowId);
+    }
+    if (reason === "device_activation_revoked") {
+        return { mode: "rejected", flowId, reason };
+    }
+    return null;
+}
+export function mapDeviceActivationTerminal(flowId, terminal) {
+    if (terminal.state === "completed") {
+        return terminal.output
+            ? mapDeviceActivationOutput(flowId, terminal.output)
+            : null;
+    }
+    return terminal.error
+        ? mapDeviceActivationFailure(flowId, terminal.error)
+        : null;
+}

package/dist/internal/callback_state.d.ts

@@ -0,0 +1,9 @@
+export type DeviceActivationCallbackState = {
+    flowId: string;
+    callbackToken: string;
+};
+export type StorageLike = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+export declare function getPreservedDeviceActivationCallbackState(storage: StorageLike): DeviceActivationCallbackState | null;
+export declare function preserveDeviceActivationCallbackState(storage: StorageLike, nextState: DeviceActivationCallbackState): void;
+export declare function clearPreservedDeviceActivationCallbackState(storage: StorageLike): void;
+export declare function isDeviceActivationAuthCallback(currentUrl: URL, preservedState: DeviceActivationCallbackState | null): boolean;

package/dist/internal/callback_state.js

@@ -0,0 +1,24 @@
+const PRESERVED_ACTIVATION_FLOW_ID_STORAGE_KEY = "portal.activate.flowId";
+const ACTIVATION_CALLBACK_TOKEN_STORAGE_KEY = "portal.activate.callbackToken";
+const ACTIVATION_CALLBACK_QUERY_PARAM = "portalCallback";
+export function getPreservedDeviceActivationCallbackState(storage) {
+    const flowId = storage.getItem(PRESERVED_ACTIVATION_FLOW_ID_STORAGE_KEY);
+    const callbackToken = storage.getItem(ACTIVATION_CALLBACK_TOKEN_STORAGE_KEY);
+    if (!flowId || !callbackToken)
+        return null;
+    return { flowId, callbackToken };
+}
+export function preserveDeviceActivationCallbackState(storage, nextState) {
+    storage.setItem(PRESERVED_ACTIVATION_FLOW_ID_STORAGE_KEY, nextState.flowId);
+    storage.setItem(ACTIVATION_CALLBACK_TOKEN_STORAGE_KEY, nextState.callbackToken);
+}
+export function clearPreservedDeviceActivationCallbackState(storage) {
+    storage.removeItem(PRESERVED_ACTIVATION_FLOW_ID_STORAGE_KEY);
+    storage.removeItem(ACTIVATION_CALLBACK_TOKEN_STORAGE_KEY);
+}
+export function isDeviceActivationAuthCallback(currentUrl, preservedState) {
+    if (!preservedState)
+        return false;
+    return currentUrl.searchParams.get(ACTIVATION_CALLBACK_QUERY_PARAM) ===
+        preservedState.callbackToken;
+}

package/dist/internal/portal_url.d.ts

@@ -0,0 +1,13 @@
+import type { DeviceActivationCallbackState } from "./callback_state.js";
+export type DeviceActivationConnectAuthUrlState = {
+    currentUrl: URL;
+    redirectTo: string;
+};
+export type DeviceActivationUrlState = {
+    flowId: string | null;
+    isAuthCallback: boolean;
+};
+export declare function buildDeviceActivationCallbackPath(currentUrl: URL, callbackToken: string): string;
+export declare function buildDeviceActivationConnectAuthUrlState(currentUrl: URL): DeviceActivationConnectAuthUrlState;
+export declare function cleanupDeviceActivationCallbackUrl(currentUrl: URL, flowId: string | null): string | null;
+export declare function resolveDeviceActivationUrlState(currentUrl: URL, preservedState: DeviceActivationCallbackState | null): DeviceActivationUrlState;

package/dist/internal/portal_url.js

@@ -0,0 +1,57 @@
+import { isDeviceActivationAuthCallback } from "./callback_state.js";
+const ACTIVATION_CALLBACK_QUERY_PARAM = "portalCallback";
+const AUTH_ERROR_QUERY_PARAM = "authError";
+const DEVICE_FLOW_ID_QUERY_PARAM = "deviceFlowId";
+const FLOW_ID_QUERY_PARAM = "flowId";
+export function buildDeviceActivationCallbackPath(currentUrl, callbackToken) {
+    const callbackUrl = new URL(currentUrl.pathname, currentUrl.origin);
+    callbackUrl.searchParams.set(ACTIVATION_CALLBACK_QUERY_PARAM, callbackToken);
+    const flowId = currentUrl.searchParams.get(FLOW_ID_QUERY_PARAM);
+    if (flowId) {
+        callbackUrl.searchParams.set(DEVICE_FLOW_ID_QUERY_PARAM, flowId);
+    }
+    callbackUrl.hash = currentUrl.hash;
+    return `${callbackUrl.pathname}${callbackUrl.search}${callbackUrl.hash}`;
+}
+export function buildDeviceActivationConnectAuthUrlState(currentUrl) {
+    const redirectUrl = new URL(currentUrl);
+    redirectUrl.searchParams.delete(ACTIVATION_CALLBACK_QUERY_PARAM);
+    redirectUrl.searchParams.delete(AUTH_ERROR_QUERY_PARAM);
+    redirectUrl.searchParams.delete(DEVICE_FLOW_ID_QUERY_PARAM);
+    const authCurrentUrl = new URL(redirectUrl);
+    authCurrentUrl.searchParams.delete(DEVICE_FLOW_ID_QUERY_PARAM);
+    authCurrentUrl.searchParams.delete(FLOW_ID_QUERY_PARAM);
+    return {
+        currentUrl: authCurrentUrl,
+        redirectTo: redirectUrl.toString(),
+    };
+}
+export function cleanupDeviceActivationCallbackUrl(currentUrl, flowId) {
+    if (!currentUrl.searchParams.has(FLOW_ID_QUERY_PARAM) &&
+        !currentUrl.searchParams.has(AUTH_ERROR_QUERY_PARAM) &&
+        !currentUrl.searchParams.has(DEVICE_FLOW_ID_QUERY_PARAM) &&
+        !currentUrl.searchParams.has(ACTIVATION_CALLBACK_QUERY_PARAM)) {
+        return null;
+    }
+    const nextUrl = new URL(currentUrl);
+    nextUrl.searchParams.delete(FLOW_ID_QUERY_PARAM);
+    nextUrl.searchParams.delete(AUTH_ERROR_QUERY_PARAM);
+    nextUrl.searchParams.delete(DEVICE_FLOW_ID_QUERY_PARAM);
+    nextUrl.searchParams.delete(ACTIVATION_CALLBACK_QUERY_PARAM);
+    if (flowId) {
+        nextUrl.searchParams.set(FLOW_ID_QUERY_PARAM, flowId);
+    }
+    return `${nextUrl.pathname}${nextUrl.search}${nextUrl.hash}`;
+}
+export function resolveDeviceActivationUrlState(currentUrl, preservedState) {
+    const callbackFlowId = currentUrl.searchParams.get(DEVICE_FLOW_ID_QUERY_PARAM);
+    const isAuthCallback = isDeviceActivationAuthCallback(currentUrl, preservedState) ||
+        (currentUrl.searchParams.has(ACTIVATION_CALLBACK_QUERY_PARAM) &&
+            !!callbackFlowId);
+    return {
+        flowId: isAuthCallback
+            ? preservedState?.flowId ?? callbackFlowId
+            : currentUrl.searchParams.get(FLOW_ID_QUERY_PARAM),
+        isAuthCallback,
+    };
+}