@qlever-llc/trellis-svelte 0.10.12 → 0.10.14

package/dist/components/TrellisContextProvider.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Component, Snippet } from "svelte";
+import type { TrellisAppOwner, TrellisContextClient } from "../context.js";
+
+type TrellisContextProviderProps = {
+  trellisApp: TrellisAppOwner;
+  trellis: TrellisContextClient;
+  children: Snippet;
+};
+
+declare const TrellisContextProvider: Component<TrellisContextProviderProps>;
+export default TrellisContextProvider;

package/dist/components/TrellisProvider.svelte

@@ -4,7 +4,7 @@
     TrellisClient,
     type ClientAuthOptions,
     type ConnectedTrellisClient,
-  } from "@qlever-llc/trellis";
+  } from "@qlever-llc/trellis/browser";
   import { onMount } from "svelte";
   import type { TrellisContractLike } from "../context.js";
   import { resolveTrellisAppUrl } from "../context.js";

package/dist/components/TrellisProvider.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { Component } from "svelte";
+import type { TrellisProviderProps } from "./TrellisProvider.types.js";
+
+/** Svelte component that connects a Trellis app and provides context to children. */
+declare const TrellisProvider: Component<TrellisProviderProps>;
+export default TrellisProvider;

package/dist/components/TrellisProvider.types.d.ts

@@ -0,0 +1,13 @@
+import type { ClientAuthOptions, ClientAuthRequiredContext, ClientOpts } from "@qlever-llc/trellis";
+import type { Snippet } from "svelte";
+import type { TrellisAppOwner, TrellisContractLike } from "../context.js";
+/** Props accepted by the Svelte Trellis provider component. */
+export type TrellisProviderProps<TContract extends TrellisContractLike = TrellisContractLike> = {
+    trellisApp: TrellisAppOwner<TContract>;
+    auth?: ClientAuthOptions;
+    client?: ClientOpts;
+    children: Snippet;
+    loading?: Snippet;
+    error?: Snippet<[unknown]>;
+    onAuthRequired?: (loginUrl: string, context: ClientAuthRequiredContext) => void | Promise<void>;
+};

package/dist/context.d.ts

@@ -0,0 +1,81 @@
+import type { ClientTrellis, RuntimeStateStoresForContract, TrellisAPI, TrellisConnection, TrellisConnectionStatus, TrellisContractV1 } from "@qlever-llc/trellis";
+/** Minimal contract shape required to create a typed Trellis Svelte app context. */
+export type TrellisContractLike<TA extends TrellisAPI = TrellisAPI> = {
+    CONTRACT: TrellisContractV1;
+    CONTRACT_DIGEST: string;
+    API: {
+        trellis?: TA;
+    };
+};
+type TrellisApiFor<TContract extends TrellisContractLike> = NonNullable<TContract["API"]["trellis"]> extends TrellisAPI ? NonNullable<TContract["API"]["trellis"]> : TrellisAPI;
+/** Real connected Trellis client type exposed by a Svelte app context. */
+export type TrellisClientFor<TContract extends TrellisContractLike> = ClientTrellis<TrellisApiFor<TContract>, RuntimeStateStoresForContract<TContract>>;
+/** Minimal client surface required for Trellis Svelte context clients. */
+export type TrellisContextClient = {
+    readonly connection: TrellisConnection;
+};
+/** URL value accepted by a Trellis Svelte app owner. */
+export type TrellisAppUrl = string | URL;
+/**
+ * Trellis URL configuration for a Svelte app owner.
+ *
+ * A function resolver supports apps whose Trellis instance is selected at
+ * runtime. Returning `undefined` means no instance is currently available.
+ */
+export type TrellisAppUrlResolver = TrellisAppUrl | (() => TrellisAppUrl | undefined);
+/** Options used to create a Trellis Svelte app owner. */
+export type CreateTrellisAppOptions<TContract extends TrellisContractLike = TrellisContractLike> = {
+    /** Contract used by this app context and by `TrellisProvider` connections. */
+    contract: TContract;
+    /** Trellis URL, or a resolver for runtime-selected Trellis URLs. */
+    trellisUrl: TrellisAppUrlResolver;
+};
+/** Resolves a Trellis app URL config to the string shape required by the client. */
+export declare function resolveTrellisAppUrl(trellisUrl: TrellisAppUrlResolver): string | undefined;
+/** Svelte-reactive adapter around a framework-neutral Trellis connection. */
+export declare class SvelteTrellisConnection {
+    #private;
+    /** Creates a reactive connection adapter for a connected Trellis runtime. */
+    constructor(connection: TrellisConnection);
+    /** Latest connection status, reactive when read by Svelte effects or markup. */
+    get status(): TrellisConnectionStatus;
+    /** Closes the underlying Trellis runtime connection. */
+    close(): Promise<void>;
+}
+declare const trellisAppOwnerBrand: unique symbol;
+/** Minimal branded app owner surface accepted by the Trellis Svelte provider. */
+export type TrellisAppOwner<TContract extends TrellisContractLike = TrellisContractLike> = {
+    readonly contract: TContract;
+    readonly trellisUrl: TrellisAppUrlResolver;
+    readonly [trellisAppOwnerBrand]: true;
+};
+/**
+ * Public app-scoped typed Svelte context owner for a Trellis browser app.
+ *
+ * `TClient` is a type-only facade over the runtime client that `TrellisProvider`
+ * installs. Use it with generated client facade types for the same contract.
+ */
+export interface TrellisApp<TContract extends TrellisContractLike = TrellisContractLike, TClient extends TrellisContextClient = TrellisClientFor<TContract>> extends TrellisAppOwner<TContract> {
+    /** Contract used by this app context and by `TrellisProvider` connections. */
+    readonly contract: TContract;
+    /** Trellis URL configuration used by `TrellisProvider` connections. */
+    readonly trellisUrl: TrellisAppUrlResolver;
+    /** Returns the contract-typed connected Trellis client from Svelte context synchronously. */
+    getTrellis(): TClient;
+    /** Returns a Svelte-reactive adapter for the real Trellis connection. */
+    getConnection(): SvelteTrellisConnection;
+}
+/**
+ * Creates an app-scoped typed Svelte context owner for a Trellis contract and URL.
+ *
+ * The optional `TClient` type parameter is a type-only facade over the connected
+ * runtime client. It should be a generated client facade for `options.contract`.
+ */
+export declare function createTrellisApp<TContract extends TrellisContractLike, TClient extends TrellisContextClient = TrellisClientFor<TContract>>(options: CreateTrellisAppOptions<TContract>): TrellisApp<TContract, TClient>;
+/**
+ * Internal provider helper that synchronously installs connected Trellis context.
+ *
+ * This is intentionally not exported from `src/index.ts`.
+ */
+export declare function provideConnectedTrellisContext(app: TrellisAppOwner, trellis: TrellisContextClient): void;
+export {};

package/dist/device_activation.d.ts

@@ -0,0 +1,6 @@
+import { type DeviceActivationControllerConfig, DeviceActivationControllerCore } from "./device_activation_controller.js";
+export type { DeviceActivationAuth, DeviceActivationClient, DeviceActivationControllerConfig, DeviceActivationOperationRef, } from "./device_activation_controller.js";
+export declare class DeviceActivationController extends DeviceActivationControllerCore {
+    constructor(config: DeviceActivationControllerConfig);
+}
+export declare function createDeviceActivationController(config: DeviceActivationControllerConfig): DeviceActivationController;

package/dist/device_activation_controller.d.ts

@@ -0,0 +1,69 @@
+import type { BaseError } from "@qlever-llc/result";
+import type { AsyncResult } from "@qlever-llc/result";
+import type { AuthResolveDeviceUserAuthoritiesOutput, AuthResolveDeviceUserAuthoritiesProgress } from "@qlever-llc/trellis/auth";
+import type { OperationEvent, TerminalOperation } from "@qlever-llc/trellis";
+import { type StorageLike } from "./internal/callback_state.js";
+import { type DeviceActivationConnectAuthUrlState } from "./internal/portal_url.js";
+import { type DeviceActivationView } from "./internal/activation_view.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<never>;
+};
+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<AuthResolveDeviceUserAuthoritiesProgress, AuthResolveDeviceUserAuthoritiesOutput>>, BaseError>;
+    wait(): AsyncResult<TerminalOperation<AuthResolveDeviceUserAuthoritiesProgress, AuthResolveDeviceUserAuthoritiesOutput>, BaseError>;
+};
+export type DeviceActivationClient = {
+    activateDevice(input: {
+        flowId: string;
+    }): Promise<DeviceActivationOperationRef>;
+};
+export type DeviceActivationState = {
+    loading: boolean;
+    requestPending: boolean;
+    authError: string | null;
+    view: DeviceActivationView | null;
+    flowId: string | null;
+};
+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;
+    load(): Promise<void>;
+    stop(): void;
+    signIn(): Promise<void>;
+    requestActivation(): Promise<void>;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+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, TrellisContractLike, } from "./context.js";
+export { createTrellisApp, resolveTrellisAppUrl } from "./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/internal/activation_view.d.ts

@@ -0,0 +1,49 @@
+import type { AuthResolveDeviceUserAuthoritiesOutput } from "@qlever-llc/trellis/auth";
+import type { TerminalOperation } from "@qlever-llc/trellis";
+type DeviceActivationProgressInput = {
+    instanceId: string;
+    deploymentId: string;
+    reviewId: string;
+    requestedAt: string | Date;
+};
+export type DeviceActivationView = {
+    mode: "sign_in_required";
+    flowId: string;
+} | {
+    mode: "ready";
+    flowId: string;
+} | {
+    mode: "pending_review";
+    flowId: string;
+    instanceId: string;
+    deploymentId: string;
+    reviewId: string;
+    requestedAt: string;
+} | {
+    mode: "activated";
+    flowId: string;
+    instanceId: string;
+    deploymentId: string;
+    activatedAt: string;
+    confirmationCode?: string;
+} | {
+    mode: "rejected";
+    flowId: string;
+    reason?: string;
+} | {
+    mode: "expired";
+    flowId: string;
+    reason: string;
+} | {
+    mode: "invalid_flow";
+    reason: string;
+    flowId?: string;
+};
+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: AuthResolveDeviceUserAuthoritiesOutput): DeviceActivationView;
+export declare function mapDeviceActivationProgress(flowId: string, progress: DeviceActivationProgressInput): DeviceActivationView;
+export declare function mapDeviceActivationFailure(flowId: string, error: unknown): DeviceActivationView | null;
+export declare function mapDeviceActivationTerminal(flowId: string, terminal: TerminalOperation<unknown, AuthResolveDeviceUserAuthoritiesOutput>): DeviceActivationView | null;
+export {};

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/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/portal_flow.d.ts

@@ -0,0 +1,17 @@
+import { type AuthConfig, type BrowserPortalFlowState as PortalFlowState } from "@qlever-llc/trellis/auth/browser";
+export type CreatePortalFlowConfig = AuthConfig & {
+    getUrl?: () => URL;
+};
+export declare class PortalFlowController {
+    #private;
+    flowId: string | null;
+    state: PortalFlowState | null;
+    loading: boolean;
+    error: string | null;
+    constructor(config: CreatePortalFlowConfig);
+    load(): Promise<PortalFlowState | null>;
+    providerUrl(providerId: string): string;
+    approve(): Promise<PortalFlowState | null>;
+    deny(): Promise<PortalFlowState | null>;
+}
+export declare function createPortalFlow(config: CreatePortalFlowConfig): PortalFlowController;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qlever-llc/trellis-svelte",
-  "version": "0.10.12",
+  "version": "0.10.14",
   "type": "module",
   "description": "Svelte components and state helpers for Trellis browser applications.",
   "license": "Apache-2.0",
@@ -20,18 +20,20 @@
     "src",
     "README.md"
   ],
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "svelte": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },
   "dependencies": {
     "@nats-io/nats-core": "^3.3.1",
-    "@qlever-llc/result": "^0.10.12",
-    "@qlever-llc/trellis": "^0.10.12",
-    "typebox": "^1.0.15"
+    "@qlever-llc/result": "^0.10.14",
+    "@qlever-llc/trellis": "^0.10.14",
+    "typebox": "^1.0.15",
+    "ulid": "^3.0.2"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"

package/src/components/TrellisProvider.svelte

@@ -4,7 +4,7 @@
     TrellisClient,
     type ClientAuthOptions,
     type ConnectedTrellisClient,
-  } from "@qlever-llc/trellis";
+  } from "@qlever-llc/trellis/browser";
   import { onMount } from "svelte";
   import type { TrellisContractLike } from "../context.svelte.ts";
   import { resolveTrellisAppUrl } from "../context.svelte.ts";