@microsoft/rayfin-auth-provider-fabric 1.20.0

package/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+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/README.md

@@ -0,0 +1,43 @@
+# @microsoft/rayfin-auth-provider-fabric
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which
+includes all source code repositories in our GitHub organizations.
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+For security reporting information, locations, contact information, and policies,
+please review the latest guidance for Microsoft repositories at
+[https://aka.ms/SECURITY.md](https://aka.ms/SECURITY.md).
+
+## Trademarks
+
+This project may contain trademarks or logos for projects, products, or services.
+Authorized use of Microsoft trademarks or logos must follow the [Microsoft Trademark and Brand Guidelines](https://www.microsoft.com/legal/intellectualproperty/trademarks/usage/general).
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+Any use of third-party trademarks or logos is subject to those third parties' policies.
+
+## License
+
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+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/bridgeFabricCallback.d.ts

@@ -0,0 +1,19 @@
+/** @internal BroadcastChannel name for backward-compat cross-tab handoff messaging. */
+export declare const FABRIC_AUTH_CHANNEL = "rayfin_fabric_auth";
+/**
+ * Bridge for backward compatibility with legacy broker redirect flows.
+ *
+ * Legacy brokers redirect the popup to the SPA's callback URL with handoff
+ * params instead of using postMessage. This function detects that scenario,
+ * forwards the params to the opener tab, and closes the popup.
+ *
+ * Delivery: postMessage when `window.opener` exists, BroadcastChannel otherwise.
+ *
+ * Call early in your callback page. Returns `true` if bridge fired (skip
+ * other callback handling), `false` if no handoff params detected.
+ *
+ * @deprecated Remove once legacy redirect flow is fully retired.
+ * @returns Whether a bridge message was sent.
+ */
+export declare function bridgeFabricCallback(): boolean;
+//# sourceMappingURL=bridgeFabricCallback.d.ts.map

package/dist/bridgeFabricCallback.js

@@ -0,0 +1,73 @@
+/** @internal BroadcastChannel name for backward-compat cross-tab handoff messaging. */
+export const FABRIC_AUTH_CHANNEL = 'rayfin_fabric_auth';
+/**
+ * Bridge for backward compatibility with legacy broker redirect flows.
+ *
+ * Legacy brokers redirect the popup to the SPA's callback URL with handoff
+ * params instead of using postMessage. This function detects that scenario,
+ * forwards the params to the opener tab, and closes the popup.
+ *
+ * Delivery: postMessage when `window.opener` exists, BroadcastChannel otherwise.
+ *
+ * Call early in your callback page. Returns `true` if bridge fired (skip
+ * other callback handling), `false` if no handoff params detected.
+ *
+ * @deprecated Remove once legacy redirect flow is fully retired.
+ * @returns Whether a bridge message was sent.
+ */
+export function bridgeFabricCallback() {
+    // Query params first, then hash fragment. Only match verification_code/code
+    // from query params when window.opener exists (popup context) to avoid
+    // colliding with magic-link callbacks that use the same param names.
+    const queryParams = new URLSearchParams(window.location.search);
+    const hashRaw = window.location.hash.startsWith('#')
+        ? window.location.hash.slice(1)
+        : window.location.hash;
+    const hashParams = new URLSearchParams(hashRaw);
+    // With opener: any code param could be a brokered handoff.
+    // Without opener: only the explicit `handoff` param is unambiguous.
+    const queryHandoffCode = window.opener
+        ? queryParams.get('verification_code') ||
+            queryParams.get('code') ||
+            queryParams.get('handoff')
+        : queryParams.get('handoff');
+    const handoffCode = queryHandoffCode ||
+        hashParams.get('handoff') ||
+        hashParams.get('verification_code') ||
+        hashParams.get('code') ||
+        null;
+    const state = queryParams.get('state') || hashParams.get('state') || null;
+    if (!handoffCode || !state) {
+        return false;
+    }
+    const payload = { type: 'brokeredAuth.handoff', state, handoffCode };
+    if (window.opener) {
+        // postMessage to same-origin opener.
+        console.debug('[FabricAuth] Bridge: forwarding handoff via postMessage to opener');
+        window.opener.postMessage(payload, window.location.origin);
+    }
+    else {
+        // Opener severed — fall back to BroadcastChannel.
+        console.debug('[FabricAuth] Bridge: no opener — forwarding handoff via BroadcastChannel');
+        try {
+            const channel = new BroadcastChannel(FABRIC_AUTH_CHANNEL);
+            channel.postMessage(payload);
+            channel.close();
+        }
+        catch {
+            console.warn('[FabricAuth] Bridge: BroadcastChannel unavailable — cannot forward handoff');
+            return false;
+        }
+    }
+    // Scrub handoff params from URL
+    if (window.history?.replaceState) {
+        window.history.replaceState(null, '', window.location.pathname +
+            window.location.search
+                .replace(/[?&](?:verification_code|code|handoff|state)=[^&]*/g, '')
+                .replace(/^\?$/, ''));
+    }
+    // Attempt to close popup (no-op for user-opened tabs).
+    window.close();
+    return true;
+}
+//# sourceMappingURL=bridgeFabricCallback.js.map

package/dist/brokerUrl.d.ts

@@ -0,0 +1,14 @@
+import type { FabricAuthOptions } from './types';
+/**
+ * Constructs the broker launch URL with PKCE and state parameters.
+ *
+ * Preserves any existing path and query parameters on `fabricPortalUrl`,
+ * appends the artifact deep-link path, and adds PKCE query parameters.
+ *
+ * @param options Auth options (workspace/project IDs, portal URL).
+ * @param codeChallenge PKCE S256 code challenge.
+ * @param state CSRF/correlation state nonce.
+ * @returns Fully constructed broker URL.
+ */
+export declare function buildBrokerUrl(options: FabricAuthOptions, codeChallenge: string, state: string): string;
+//# sourceMappingURL=brokerUrl.d.ts.map

package/dist/brokerUrl.js

@@ -0,0 +1,29 @@
+/**
+ * Constructs the broker launch URL with PKCE and state parameters.
+ *
+ * Preserves any existing path and query parameters on `fabricPortalUrl`,
+ * appends the artifact deep-link path, and adds PKCE query parameters.
+ *
+ * @param options Auth options (workspace/project IDs, portal URL).
+ * @param codeChallenge PKCE S256 code challenge.
+ * @param state CSRF/correlation state nonce.
+ * @returns Fully constructed broker URL.
+ */
+export function buildBrokerUrl(options, codeChallenge, state) {
+    const portalUrl = new URL(options.fabricPortalUrl);
+    // Append artifact deep-link path
+    const basePath = portalUrl.pathname.replace(/\/$/, '');
+    const artifactPath = `/groups/${encodeURIComponent(options.workspaceId)}/appbackends/${encodeURIComponent(options.projectId)}`;
+    portalUrl.pathname = `${basePath}${artifactPath}`;
+    // `returnOrigin` must be a bare origin (scheme + host + port) — used as
+    // the postMessage targetOrigin and the redirect target for legacy brokers.
+    portalUrl.searchParams.set('returnOrigin', options.returnOrigin);
+    // Fallback redirect URL for legacy brokers that don't use postMessage.
+    const callbackUrl = options.callbackUrl || `${options.returnOrigin}/auth/callback`;
+    portalUrl.searchParams.set('callbackUrl', callbackUrl);
+    portalUrl.searchParams.set('code_challenge', codeChallenge);
+    portalUrl.searchParams.set('code_challenge_method', 'S256');
+    portalUrl.searchParams.set('state', state);
+    return portalUrl.toString();
+}
+//# sourceMappingURL=brokerUrl.js.map

package/dist/ensureSignedInWithFabric.d.ts

@@ -0,0 +1,27 @@
+import type { Auth, OpaqueSession } from '@microsoft/rayfin-auth';
+import type { FabricAuthOptions } from './types';
+/**
+ * Ensures the user is signed in via Fabric brokered authentication.
+ *
+ * Implements a 3-step waterfall — the first step that succeeds short-circuits the rest:
+ *
+ * 1. **Already authenticated** — if `auth.getSession().isAuthenticated` is true,
+ *    return the existing session immediately.
+ * 2. **Refresh token** — if a refresh token is available, attempt `auth.refreshSession()`.
+ *    Return the refreshed session on success; continue on failure.
+ * 3. **Open Fabric broker** — no existing auth path available. Open the Fabric Portal
+ *    in a new tab via `initiateFabricLogin()` and wait for the Fabric extension to post
+ *    the handoff code via `postMessage`. The function exchanges the code internally
+ *    and creates the session. Once the promise resolves, return the new session.
+ *
+ * **Step 3 calls `window.open()`** — to avoid popup/tab blockers, call this function
+ * from inside a synchronous user-gesture handler (e.g., a button click).
+ * Steps 1–2 do not open windows and are safe to call on page load.
+ *
+ * @param auth The Auth instance.
+ * @param options Fabric authentication options (workspaceId, projectId, returnOrigin).
+ * @returns A promise that resolves with the authenticated session.
+ * @throws {AuthError} If all steps fail or the broker tab is blocked.
+ */
+export declare function ensureSignedInWithFabric(auth: Auth, options: FabricAuthOptions): Promise<OpaqueSession>;
+//# sourceMappingURL=ensureSignedInWithFabric.d.ts.map

package/dist/ensureSignedInWithFabric.js

@@ -0,0 +1,65 @@
+import { AuthError } from '@microsoft/rayfin-lib';
+import { initiateFabricLogin } from './initiateFabricLogin';
+/**
+ * Ensures the user is signed in via Fabric brokered authentication.
+ *
+ * Implements a 3-step waterfall — the first step that succeeds short-circuits the rest:
+ *
+ * 1. **Already authenticated** — if `auth.getSession().isAuthenticated` is true,
+ *    return the existing session immediately.
+ * 2. **Refresh token** — if a refresh token is available, attempt `auth.refreshSession()`.
+ *    Return the refreshed session on success; continue on failure.
+ * 3. **Open Fabric broker** — no existing auth path available. Open the Fabric Portal
+ *    in a new tab via `initiateFabricLogin()` and wait for the Fabric extension to post
+ *    the handoff code via `postMessage`. The function exchanges the code internally
+ *    and creates the session. Once the promise resolves, return the new session.
+ *
+ * **Step 3 calls `window.open()`** — to avoid popup/tab blockers, call this function
+ * from inside a synchronous user-gesture handler (e.g., a button click).
+ * Steps 1–2 do not open windows and are safe to call on page load.
+ *
+ * @param auth The Auth instance.
+ * @param options Fabric authentication options (workspaceId, projectId, returnOrigin).
+ * @returns A promise that resolves with the authenticated session.
+ * @throws {AuthError} If all steps fail or the broker tab is blocked.
+ */
+export async function ensureSignedInWithFabric(auth, options) {
+    // Step 1: Already authenticated
+    console.debug('[FabricAuth] Step 1: checking for existing session');
+    const currentSession = auth.getSession();
+    if (currentSession.isAuthenticated) {
+        console.debug('[FabricAuth] Step 1: existing session found, skipping remaining steps');
+        return currentSession;
+    }
+    // Step 2: Try refresh token
+    console.debug('[FabricAuth] Step 2: checking for refresh token');
+    if (auth.hasRefreshToken()) {
+        try {
+            await auth.refreshSession();
+            const refreshedSession = auth.getSession();
+            if (refreshedSession.isAuthenticated) {
+                console.debug('[FabricAuth] Step 2: session refreshed successfully');
+                return refreshedSession;
+            }
+        }
+        catch {
+            console.warn('[FabricAuth] Step 2: session refresh failed, continuing to step 3');
+        }
+    }
+    else {
+        console.debug('[FabricAuth] Step 2: no refresh token available, skipping to step 3');
+    }
+    // Step 3: Open Fabric broker in a new tab
+    // WARNING: This calls window.open() — must be in a user-gesture context
+    console.debug('[FabricAuth] Step 3: initiating Fabric broker login');
+    await initiateFabricLogin(auth, options);
+    // Session was created inside initiateFabricLogin via createSessionFromTokenResponse
+    const newSession = auth.getSession();
+    if (newSession.isAuthenticated) {
+        console.debug('[FabricAuth] Step 3: Fabric broker login succeeded, session established');
+        return newSession;
+    }
+    console.warn('[FabricAuth] Step 3: Fabric broker login completed but no session was established');
+    throw new AuthError('Fabric authentication completed but no session was established.', 'SESSION_NOT_ESTABLISHED');
+}
+//# sourceMappingURL=ensureSignedInWithFabric.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { FabricAuthOptions } from './types';
+export { bridgeFabricCallback } from './bridgeFabricCallback';
+export { ensureSignedInWithFabric } from './ensureSignedInWithFabric';
+export { initiateFabricLogin } from './initiateFabricLogin';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+// Functions
+export { bridgeFabricCallback } from './bridgeFabricCallback';
+export { ensureSignedInWithFabric } from './ensureSignedInWithFabric';
+export { initiateFabricLogin } from './initiateFabricLogin';
+//# sourceMappingURL=index.js.map

package/dist/initiateFabricLogin.d.ts

@@ -0,0 +1,18 @@
+import type { Auth } from '@microsoft/rayfin-auth';
+import type { FabricAuthOptions } from './types';
+/**
+ * Initiates brokered authentication by opening the broker portal in a popup.
+ *
+ * **Must be called inside a user click handler** to avoid popup blockers.
+ *
+ * Generates PKCE params, opens the broker URL, and listens for a
+ * `brokeredAuth.handoff` postMessage. On handoff, exchanges the code for
+ * tokens and creates a session. The `code_verifier` is kept in closure only.
+ *
+ * @param auth Auth instance for token exchange.
+ * @param options Broker auth options (`returnOrigin` required).
+ * @returns Resolves when the session is established.
+ * @throws {AuthError} On missing options, blocked popup, or auth failure.
+ */
+export declare function initiateFabricLogin(auth: Auth, options: FabricAuthOptions): Promise<void>;
+//# sourceMappingURL=initiateFabricLogin.d.ts.map

package/dist/initiateFabricLogin.js

@@ -0,0 +1,128 @@
+import { generateCodeVerifier, generateCodeChallenge, generateState, } from '@microsoft/rayfin-auth';
+import { AuthError } from '@microsoft/rayfin-lib';
+import { FABRIC_AUTH_CHANNEL } from './bridgeFabricCallback';
+import { buildBrokerUrl } from './brokerUrl';
+/**
+ * Initiates brokered authentication by opening the broker portal in a popup.
+ *
+ * **Must be called inside a user click handler** to avoid popup blockers.
+ *
+ * Generates PKCE params, opens the broker URL, and listens for a
+ * `brokeredAuth.handoff` postMessage. On handoff, exchanges the code for
+ * tokens and creates a session. The `code_verifier` is kept in closure only.
+ *
+ * @param auth Auth instance for token exchange.
+ * @param options Broker auth options (`returnOrigin` required).
+ * @returns Resolves when the session is established.
+ * @throws {AuthError} On missing options, blocked popup, or auth failure.
+ */
+export async function initiateFabricLogin(auth, options) {
+    // Validate required params
+    if (!options.workspaceId) {
+        throw new AuthError('workspaceId is required.', 'MISSING_WORKSPACE_ID');
+    }
+    if (!options.projectId) {
+        throw new AuthError('projectId is required.', 'MISSING_PROJECT_ID');
+    }
+    if (!options.returnOrigin) {
+        throw new AuthError('returnOrigin is required for Fabric authentication.', 'MISSING_RETURN_ORIGIN');
+    }
+    if (!options.fabricPortalUrl) {
+        throw new AuthError('fabricPortalUrl is required for Fabric authentication.', 'MISSING_FABRIC_PORTAL_URL');
+    }
+    // PKCE + state
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = await generateCodeChallenge(codeVerifier);
+    const state = generateState();
+    const expectedBrokerOrigin = new URL(options.fabricPortalUrl).origin;
+    const brokerUrl = buildBrokerUrl(options, codeChallenge, state);
+    return new Promise((resolve, reject) => {
+        let fabricWindow = null;
+        let channel = null;
+        // 5-minute timeout — matches the backend's handoff code TTL.
+        const TIMEOUT_MS = 5 * 60 * 1000;
+        function cleanup() {
+            window.removeEventListener('message', handleMessage);
+            channel?.close();
+            channel = null;
+            clearTimeout(timeoutId);
+            if (fabricWindow && !fabricWindow.closed) {
+                fabricWindow.close();
+            }
+        }
+        /** Handles incoming brokeredAuth postMessage events. */
+        function handleMessage(event) {
+            // Origin check is advisory — state + PKCE provide the real security.
+            if (event.origin !== expectedBrokerOrigin) {
+                console.warn(`[FabricAuth] postMessage origin mismatch (expected="${expectedBrokerOrigin}", actual="${event.origin}") — continuing (secured by state + PKCE)`);
+            }
+            if (!event.data || typeof event.data !== 'object') {
+                console.debug('[FabricAuth] postMessage ignored: non-object payload');
+                return;
+            }
+            const { type, state: msgState } = event.data;
+            console.debug(`[FabricAuth] postMessage received: type=${String(type)}, stateMatch=${msgState === state}`);
+            if (msgState !== state) {
+                console.debug('[FabricAuth] postMessage ignored: state mismatch');
+                return;
+            }
+            if (type === 'brokeredAuth.handoff') {
+                console.debug('[FabricAuth] Handling brokeredAuth.handoff — exchanging handoff code for tokens');
+                const { handoffCode } = event.data;
+                cleanup();
+                // redirectUri must match the value the broker used when creating the handoff code.
+                const redirectUri = options.returnOrigin;
+                auth
+                    .getAuthApi()
+                    .exchangeVerificationCode({
+                    verificationCode: handoffCode,
+                    codeVerifier,
+                    codeType: 'fabric_handoff',
+                    redirectUri,
+                })
+                    .then((tokenResponse) => {
+                    console.debug('[FabricAuth] Token exchange succeeded, creating session');
+                    auth.createSessionFromTokenResponse(tokenResponse);
+                    resolve();
+                })
+                    .catch((err) => {
+                    console.warn('[FabricAuth] Token exchange failed', err);
+                    reject(err);
+                });
+            }
+            else if (type === 'brokeredAuth.error') {
+                console.warn(`[FabricAuth] Handling brokeredAuth.error — code=${String(event.data.error ?? 'unknown')}`);
+                cleanup();
+                reject(new AuthError(event.data.errorDescription || 'Fabric authentication failed.', event.data.error || 'FABRIC_AUTH_FAILED'));
+            }
+        }
+        const timeoutId = setTimeout(() => {
+            console.warn('[FabricAuth] Broker handoff timed out after 5 minutes');
+            cleanup();
+            reject(new AuthError('Fabric authentication timed out after 5 minutes. Please try again.', 'FABRIC_AUTH_TIMEOUT'));
+        }, TIMEOUT_MS);
+        // Listen for handoff via postMessage and BroadcastChannel (legacy bridge).
+        console.debug('[FabricAuth] Registering postMessage listener for broker handoff');
+        window.addEventListener('message', handleMessage);
+        try {
+            channel = new BroadcastChannel(FABRIC_AUTH_CHANNEL);
+            channel.onmessage = handleMessage;
+            console.debug('[FabricAuth] BroadcastChannel listener registered for backward-compat bridge');
+        }
+        catch {
+            console.debug('[FabricAuth] BroadcastChannel not available — relying on postMessage only');
+        }
+        // Open broker portal in a centered popup
+        const popupWidth = 600;
+        const popupHeight = 700;
+        const left = Math.round(window.screenX + (window.outerWidth - popupWidth) / 2);
+        const top = Math.round(window.screenY + (window.outerHeight - popupHeight) / 2);
+        fabricWindow = window.open(brokerUrl, 'fabricAuth', `popup=yes,width=${popupWidth},height=${popupHeight},left=${left},top=${top}`);
+        if (!fabricWindow) {
+            cleanup();
+            reject(new AuthError('Failed to open Fabric sign-in page. ' +
+                'Please allow popups for this site and try again.', 'TAB_BLOCKED'));
+        }
+    });
+}
+//# sourceMappingURL=initiateFabricLogin.js.map

package/dist/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Options for initiating Fabric brokered authentication.
+ */
+export interface FabricAuthOptions {
+    /** The Fabric workspace ID. */
+    workspaceId: string;
+    /** The Fabric project/app ID (artifact ID). */
+    projectId: string;
+    /**
+     * The Fabric Portal URL, including any existing path and query parameters.
+     * The SDK appends `/groups/{workspaceId}/appbackends/{projectId}` to the
+     * existing path and appends PKCE query parameters, preserving everything
+     * already present in the URL.
+     *
+     * Examples:
+     * - Production: `https://app.fabric.microsoft.com`
+     * - With path: `https://app.fabric.microsoft.com/some/portal/path`
+     * - Dev/test: `https://powerbi-df.analysis-df.windows.net?debug.useLocalManifests=1&experience=power-bi`
+     */
+    fabricPortalUrl: string;
+    /**
+     * The origin of the SPA that initiated the Fabric auth flow.
+     * Used as the `targetOrigin` for `postMessage` delivery of the handoff code.
+     * Must be a bare origin string (e.g., `https://myapp.com`), not a full URL with path.
+     */
+    returnOrigin: string;
+    /**
+     * Full redirect callback URL for old Fabric Portal deployments that haven't
+     * adopted postMessage yet. When provided, this URL is sent as the `callbackUrl`
+     * query parameter so the old Portal can redirect back with the handoff code.
+     *
+     * Defaults to `${returnOrigin}/auth/callback` when omitted.
+     *
+     * @deprecated Backward-compat only — will be removed once postMessage rollout is complete.
+     */
+    callbackUrl?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@microsoft/rayfin-auth-provider-fabric",
+  "version": "1.20.0",
+  "description": "Fabric brokered authentication provider for Rayfin SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/__tests__/**",
+    "LICENSE"
+  ],
+  "type": "module",
+  "dependencies": {
+    "@microsoft/rayfin-lib": "1.20.0",
+    "@microsoft/rayfin-auth": "1.20.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "@vitest/coverage-v8": "~3.2.4",
+    "rimraf": "~6.0.1"
+  },
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com",
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/project-rayfin.git",
+    "directory": "packages/typescript-sdk/auth-provider-fabric"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rimraf dist && rimraf .tsbuildinfo",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}