@flung.dev/connect 0.1.1 → 0.3.0

package/dist/core/controller.js

@@ -0,0 +1,407 @@
+import { ConnectClient, FlungConnectError } from './client.js';
+import { connectInPopup, readRedirectResult, withoutRedirectResult } from './flows.js';
+import { DEFAULT_LABELS, formatLabel } from './labels.js';
+import { HANDLE_PROMPT, isConnectVariant, isPageAccount, PLATFORM_NAMES, tokenPlatforms } from './platforms.js';
+/** How soon a reconnect deadline is worth showing. */
+const SOON_MS = 14 * 86_400_000;
+const IDLE = Object.freeze({ kind: 'idle' });
+const NO_VARIANTS = Object.freeze([]);
+/**
+ * The connect panel with no markup: it reads the platforms and accounts, runs connects, reconnects and disconnects, and
+ * keeps one immutable snapshot of it all. `<flung-connect>` and `useFlungConnect` are drawn from it; a page can draw its
+ * own panel from it too. It starts reading as soon as it has a token.
+ */
+export function createConnectController(options) {
+    return new Controller(options);
+}
+/** The snapshot a panel with no controller yet shows, the same object every time for each `hasToken`. */
+export function initialConnectState(hasToken) {
+    return hasToken ? INITIAL_WITH_TOKEN : INITIAL_WITHOUT_TOKEN;
+}
+class Controller {
+    #options;
+    #client;
+    #listeners = new Set();
+    #asked;
+    #mode;
+    #labels;
+    #platforms = [];
+    #offers = new Map();
+    #accounts = [];
+    #steps = new Map();
+    #notice = null;
+    #loading = false;
+    #loaded = false;
+    #destroyed = false;
+    #state;
+    constructor(options) {
+        this.#options = options;
+        this.#asked = options.platforms ?? null;
+        this.#mode = options.mode ?? 'popup';
+        this.#labels = { ...DEFAULT_LABELS, ...options.labels };
+        this.#client = options.token === null ? null : new ConnectClient({ token: options.token, baseUrl: options.baseUrl, fetch: options.fetch });
+        this.#loading = this.#client !== null;
+        this.#state = this.#snapshot();
+        if (this.#client !== null) {
+            void this.#load().then(() => {
+                if (options.readRedirect !== false)
+                    this.#readReturn();
+            });
+        }
+    }
+    getState = () => this.#state;
+    subscribe = (listener) => {
+        if (this.#destroyed)
+            return () => undefined;
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    };
+    configure(options) {
+        if (this.#destroyed)
+            return;
+        if (options.mode !== undefined)
+            this.#mode = options.mode;
+        let changed = false;
+        if ('labels' in options) {
+            const labels = { ...DEFAULT_LABELS, ...options.labels };
+            if (Object.keys(labels).some((key) => labels[key] !== this.#labels[key])) {
+                this.#labels = labels;
+                changed = true;
+            }
+        }
+        if ('platforms' in options) {
+            const asked = options.platforms ?? null;
+            if ((asked ?? []).join(',') !== (this.#asked ?? []).join(',')) {
+                this.#asked = asked;
+                void this.#load();
+            }
+        }
+        if (changed)
+            this.#emit();
+    }
+    destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        for (const step of this.#steps.values())
+            if (step.kind === 'waiting')
+                step.abort.abort();
+        this.#listeners.clear();
+    }
+    refresh = () => this.#load();
+    connect = (platform, options = {}) => {
+        if (!this.#ready(platform))
+            return;
+        const offer = this.#offers.get(platform);
+        let variant = options.variant ?? null;
+        if (options.variant === undefined && offer !== undefined && offer.variants.length > 0) {
+            // Both ways set up: ask. Only a variant set up: that is the connect.
+            if (offer.connectable)
+                return this.#set(platform, { kind: 'choose', variants: offer.variants });
+            variant = offer.variants[0] ?? null;
+        }
+        const prompt = HANDLE_PROMPT[platform];
+        if (variant === null && prompt !== undefined)
+            return this.#set(platform, { kind: 'handle', required: prompt.required });
+        this.#start(platform, null, undefined, variant);
+    };
+    submitHandle = (platform, handle) => {
+        if (!this.#ready(platform))
+            return;
+        const trimmed = handle.trim();
+        this.#start(platform, null, trimmed === '' ? undefined : trimmed, null);
+    };
+    reconnect = (accountId) => {
+        const account = this.#accounts.find((candidate) => candidate.id === accountId);
+        if (account === undefined || !this.#ready(account.platform))
+            return;
+        // The API reconnects through the app the account was connected with, so a page needs no variant here.
+        this.#start(account.platform, account, undefined, null);
+    };
+    requestDisconnect = (accountId) => {
+        const account = this.#accounts.find((candidate) => candidate.id === accountId);
+        if (account === undefined || !this.#ready(account.platform))
+            return;
+        this.#set(account.platform, { kind: 'confirm', account });
+    };
+    confirmDisconnect = async (platform) => {
+        const step = this.#steps.get(platform);
+        const client = this.#client;
+        if (step?.kind !== 'confirm' || client === null || this.#destroyed)
+            return;
+        this.#set(platform, { kind: 'idle' });
+        try {
+            const disconnected = await client.disconnect(step.account.id);
+            if (this.#destroyed)
+                return;
+            await this.#load();
+            this.#tell({ kind: 'disconnected', account: step.account });
+            this.#options.onDisconnect?.({ account: disconnected });
+        }
+        catch (error) {
+            this.#fail(error, 'disconnect', platform);
+        }
+    };
+    cancel = (platform) => {
+        const step = this.#steps.get(platform);
+        if (step === undefined || step.kind === 'idle')
+            return;
+        if (step.kind === 'waiting')
+            step.abort.abort();
+        this.#set(platform, { kind: 'idle' });
+    };
+    dismissNotice = () => {
+        if (this.#notice !== null)
+            this.#tell(null);
+    };
+    /** A connect may start: there is a token, and the platform is not already waiting on one. */
+    #ready(platform) {
+        return !this.#destroyed && this.#client !== null && this.#steps.get(platform)?.kind !== 'waiting';
+    }
+    async #load() {
+        const client = this.#client;
+        if (client === null || this.#destroyed)
+            return;
+        if (!this.#loading) {
+            this.#loading = true;
+            this.#emit();
+        }
+        try {
+            const [platforms, accounts] = await Promise.all([client.platforms(), client.accounts()]);
+            if (this.#destroyed)
+                return;
+            const asked = this.#asked;
+            const granted = typeof this.#options.token === 'string' ? tokenPlatforms(this.#options.token) : null;
+            const offered = platforms
+                .map((info) => ({ platform: info.platform, connectable: info.connectable, variants: (info.variants ?? []).filter(isConnectVariant) }))
+                .filter((info) => (info.connectable || info.variants.length > 0) && (asked ?? [info.platform]).includes(info.platform) && (granted ?? [info.platform]).includes(info.platform));
+            this.#platforms = offered.map((info) => info.platform);
+            this.#offers = new Map(offered.map((info) => [info.platform, Object.freeze({ connectable: info.connectable, variants: Object.freeze(info.variants) })]));
+            this.#accounts = accounts.filter((account) => account.status !== 'disconnected' && this.#platforms.includes(account.platform));
+            this.#loading = false;
+            this.#loaded = true;
+            this.#emit();
+            this.#options.onLoad?.({ accounts: this.#accounts });
+        }
+        catch (error) {
+            if (this.#destroyed)
+                return;
+            this.#loading = false;
+            this.#fail(error, 'load', null);
+        }
+    }
+    /** A connect that left the page (`mode: 'redirect'`) and came back: report it, and take Flung's result off the address. */
+    #readReturn() {
+        if (this.#destroyed || typeof location === 'undefined' || typeof history === 'undefined')
+            return;
+        const result = readRedirectResult(location.href);
+        if (result === null)
+            return;
+        history.replaceState(history.state, '', withoutRedirectResult(location.href));
+        if (result.status === 'connected') {
+            const accounts = this.#accounts.filter((account) => result.accountIds.includes(account.id));
+            this.#tell({ kind: 'connected', platform: accounts[0]?.platform ?? null, accounts, session: null });
+            this.#options.onConnect?.({ session: null, accounts });
+        }
+        else {
+            const code = result.error?.code ?? 'platform_error';
+            const message = result.error?.message ?? '';
+            this.#tell({ kind: 'error', during: 'redirect', platform: null, code, message });
+            this.#options.onError?.({ code, message });
+        }
+    }
+    /** Called straight from a click or a submit: a window can only be opened during one. */
+    #start(platform, account, handle, variant) {
+        const client = this.#client;
+        const redirect = this.#mode === 'redirect' && typeof location !== 'undefined';
+        const redirectUrl = redirect ? withoutRedirectResult(location.href) : undefined;
+        const begin = () => (account === null ? client.connect(platform, { handle, redirectUrl, variant: variant ?? undefined }) : client.reconnect(account.id, { redirectUrl }));
+        const abort = new AbortController();
+        const step = { kind: 'waiting', abort, blockedUrl: null, accountId: account?.id ?? null, variant };
+        this.#notice = null;
+        this.#set(platform, step);
+        if (redirect) {
+            void begin().then((session) => {
+                const url = safeUrl(session.authorizationUrl);
+                if (url !== null && !this.#destroyed)
+                    location.assign(url);
+            }, (error) => this.#settle(platform, step, error));
+            return;
+        }
+        void connectInPopup(client, begin, { signal: abort.signal })
+            .then(async (outcome) => {
+            if (outcome.kind === 'finished')
+                return outcome.session;
+            if (this.#steps.get(platform) === step)
+                this.#set(platform, { ...step, blockedUrl: safeUrl(outcome.session.authorizationUrl) });
+            return client.waitForSession(outcome.session.id, { signal: abort.signal });
+        })
+            .then((session) => this.#finish(platform, session), (error) => this.#settle(platform, step, error));
+    }
+    async #finish(platform, session) {
+        if (this.#destroyed)
+            return;
+        this.#set(platform, { kind: 'idle' });
+        if (session.status === 'connected') {
+            await this.#load();
+            if (this.#destroyed)
+                return;
+            const accounts = this.#accounts.filter((account) => session.accountIds.includes(account.id));
+            this.#tell({ kind: 'connected', platform, accounts, session });
+            this.#options.onConnect?.({ session, accounts });
+        }
+        else if (session.status === 'expired') {
+            this.#tell({ kind: 'expired', platform });
+            this.#options.onError?.({ code: 'expired', message: this.#state.message.text });
+        }
+        else {
+            const code = session.error?.code ?? 'platform_error';
+            const message = session.error?.message ?? '';
+            this.#tell({ kind: 'error', during: 'connect', platform, code, message });
+            this.#options.onError?.({ code, message });
+        }
+    }
+    /** A connect that stopped early: cancelled by the person, or refused by the API. */
+    #settle(platform, step, error) {
+        if (this.#destroyed)
+            return;
+        if (this.#steps.get(platform) === step)
+            this.#set(platform, { kind: 'idle' });
+        // By name and by the signal, not `instanceof DOMException`: the reason may come from another realm's DOMException.
+        const aborted = (step.kind === 'waiting' && step.abort.signal.aborted) || (typeof error === 'object' && error !== null && error.name === 'AbortError');
+        if (aborted)
+            return;
+        this.#fail(error, 'connect', platform);
+    }
+    #fail(error, during, platform) {
+        if (this.#destroyed)
+            return;
+        const detail = error instanceof FlungConnectError ? { code: error.code, message: error.message } : { code: 'unknown', message: String(error) };
+        this.#tell({ kind: 'error', during, platform, ...detail });
+        this.#options.onError?.(detail);
+    }
+    #set(platform, step) {
+        this.#steps.set(platform, step);
+        this.#emit();
+    }
+    #tell(notice) {
+        this.#notice = notice;
+        this.#emit();
+    }
+    #emit() {
+        if (this.#destroyed)
+            return;
+        this.#state = this.#snapshot();
+        for (const listener of [...this.#listeners])
+            listener();
+    }
+    #snapshot() {
+        const now = Date.now();
+        const items = new Map(this.#accounts.map((account) => [account.id, accountItem(account, now)]));
+        const platforms = this.#platforms.map((platform) => {
+            const step = publicStep(this.#steps.get(platform), items, now);
+            const prompt = HANDLE_PROMPT[platform];
+            const offer = this.#offers.get(platform);
+            return Object.freeze({
+                platform,
+                name: PLATFORM_NAMES[platform],
+                accounts: Object.freeze(this.#accounts.filter((account) => account.platform === platform).map((account) => items.get(account.id))),
+                step,
+                busy: step.kind === 'waiting',
+                handlePrompt: prompt === undefined ? null : Object.freeze({ required: prompt.required }),
+                connectable: offer?.connectable ?? true,
+                variants: offer?.variants ?? NO_VARIANTS,
+            });
+        });
+        return Object.freeze({
+            hasToken: this.#client !== null,
+            loading: this.#loading,
+            loaded: this.#loaded,
+            platforms: Object.freeze(platforms),
+            accounts: Object.freeze([...this.#accounts]),
+            notice: this.#notice,
+            message: Object.freeze(statusLine(this.#notice, this.#client !== null, this.#loaded, this.#platforms.length, this.#labels)),
+            labels: Object.freeze({ ...this.#labels }),
+        });
+    }
+}
+function publicStep(step, items, now) {
+    if (step === undefined || step.kind === 'idle')
+        return IDLE;
+    if (step.kind === 'handle')
+        return Object.freeze({ kind: 'handle', required: step.required });
+    if (step.kind === 'choose')
+        return Object.freeze({ kind: 'choose', variants: step.variants });
+    if (step.kind === 'waiting')
+        return Object.freeze({ kind: 'waiting', blockedUrl: step.blockedUrl, accountId: step.accountId, variant: step.variant });
+    return Object.freeze({ kind: 'confirm', account: items.get(step.account.id) ?? accountItem(step.account, now) });
+}
+/** What to show for an account. */
+function accountItem(account, now) {
+    const name = account.username ?? account.platformUserId;
+    const shown = nonEmpty(account.displayName) ?? name;
+    const username = account.username !== null && account.username !== shown ? account.username : null;
+    const due = account.reconnectBy === null ? null : Date.parse(account.reconnectBy);
+    const reconnect = account.status === 'needs_reconnect' ? { reason: 'needs_reconnect' } : due !== null && !Number.isNaN(due) && due - now < SOON_MS ? { reason: 'deadline', by: account.reconnectBy } : null;
+    return Object.freeze({ account, name, displayName: shown, username, avatarUrl: safeUrl(account.avatarUrl ?? null, ['https:']), initial: initialOf(shown), page: isPageAccount(account), reconnect });
+}
+function statusLine(notice, hasToken, loaded, offered, labels) {
+    if (notice !== null)
+        return { text: noticeText(notice, labels), error: notice.kind === 'error' || notice.kind === 'expired' };
+    if (!hasToken)
+        return { text: labels.noToken, error: false };
+    if (offered === 0)
+        return { text: loaded ? labels.empty : labels.loading, error: false };
+    return { text: '', error: false };
+}
+function noticeText(notice, labels) {
+    switch (notice.kind) {
+        case 'connected':
+            return formatLabel(labels.connected, { platform: notice.platform === null ? 'The account' : PLATFORM_NAMES[notice.platform] });
+        case 'disconnected':
+            return formatLabel(labels.disconnected, { account: notice.account.username ?? notice.account.platformUserId });
+        case 'expired':
+            return formatLabel(labels.expired, { platform: PLATFORM_NAMES[notice.platform] });
+        case 'error':
+            if (notice.during === 'load')
+                return formatLabel(labels.loadFailed, { message: notice.message });
+            if (notice.during === 'connect' && notice.platform !== null)
+                return formatLabel(labels.failed, { platform: PLATFORM_NAMES[notice.platform], message: notice.message });
+            return notice.message;
+    }
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : null;
+}
+/** The first letter of a name, without a leading `@`, upper-cased; `?` when there is none. */
+function initialOf(name) {
+    const first = Array.from(name.replace(/^@+/, '').trim())[0];
+    return first === undefined ? '?' : first.toLocaleUpperCase();
+}
+/** `value` when it is an address on one of `protocols`, else null: an address from the API never becomes a `javascript:` link. */
+function safeUrl(value, protocols = ['https:', 'http:']) {
+    if (value === null)
+        return null;
+    try {
+        return protocols.includes(new URL(value).protocol) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function frozenInitial(hasToken) {
+    return Object.freeze({
+        hasToken,
+        loading: hasToken,
+        loaded: false,
+        platforms: Object.freeze([]),
+        accounts: Object.freeze([]),
+        notice: null,
+        message: Object.freeze(statusLine(null, hasToken, false, 0, DEFAULT_LABELS)),
+        labels: Object.freeze({ ...DEFAULT_LABELS }),
+    });
+}
+const INITIAL_WITH_TOKEN = frozenInitial(true);
+const INITIAL_WITHOUT_TOKEN = frozenInitial(false);

package/dist/core/events.d.ts

@@ -0,0 +1,25 @@
+import type { Account, ConnectSession } from './types.js';
+/** `flung-load`: the accounts were read, on first show and after every change. */
+export interface LoadDetail {
+    /** The connected accounts the panel shows, newest first. */
+    accounts: Account[];
+}
+/** `flung-connect`: a connect or reconnect finished. `accounts` are the ones stored; Facebook stores one per page. */
+export interface ConnectDetail {
+    /** The connect session, or null when the person came back from a redirect. */
+    session: ConnectSession | null;
+    /** The accounts stored. */
+    accounts: Account[];
+}
+/** `flung-disconnect`: an account was disconnected. */
+export interface DisconnectDetail {
+    /** The account, now `disconnected`. */
+    account: Account;
+}
+/** `flung-error`: a call or a connect failed. `code` is the API's stable code, such as `forbidden` or `access_denied`. */
+export interface ErrorDetail {
+    /** The API's stable code, or the platform's, such as `access_denied`. */
+    code: string;
+    /** What went wrong, for a person. */
+    message: string;
+}

package/dist/core/events.js

@@ -0,0 +1 @@
+export {};

package/dist/core/index.d.ts

@@ -1,10 +1,16 @@
 /**
- * `@flung.dev/connect/core`: the connect calls and flows with no element, for a page that draws its own panel.
+ * `@flung.dev/connect/core`: the connect calls, flows and headless controller with no element, for a page that draws
+ * its own panel.
  */
 export { ConnectClient, DEFAULT_BASE_URL, FlungConnectError } from './client.js';
 export type { ConnectClientOptions, TokenSource } from './client.js';
+export { createConnectController, initialConnectState } from './controller.js';
+export type { AccountItem, ConnectActions, ConnectController, ConnectControllerOptions, ConnectNotice, ConnectOptions, ConnectState, PlatformItem, PlatformStep } from './controller.js';
+export type { ConnectDetail, DisconnectDetail, ErrorDetail, LoadDetail } from './events.js';
 export { connectInPopup, readRedirectResult, withoutRedirectResult } from './flows.js';
 export type { PopupOutcome, RedirectResult } from './flows.js';
-export { HANDLE_PROMPT, isPlatform, parsePlatformList, PLATFORM_NAMES, tokenPlatforms } from './platforms.js';
-export { PLATFORMS } from './types.js';
-export type { Account, AccountStatus, ConnectSession, ConnectSessionStatus, Platform, PlatformInfo } from './types.js';
+export { DEFAULT_LABELS, formatLabel } from './labels.js';
+export type { ConnectLabels } from './labels.js';
+export { HANDLE_PROMPT, isConnectVariant, isPageAccount, isPlatform, parsePlatformList, PLATFORM_NAMES, tokenPlatforms } from './platforms.js';
+export { CONNECT_VARIANTS, PLATFORMS } from './types.js';
+export type { Account, AccountStatus, ConnectSession, ConnectSessionStatus, ConnectVariant, Platform, PlatformInfo } from './types.js';

package/dist/core/index.js

@@ -1,7 +1,10 @@
 /**
- * `@flung.dev/connect/core`: the connect calls and flows with no element, for a page that draws its own panel.
+ * `@flung.dev/connect/core`: the connect calls, flows and headless controller with no element, for a page that draws
+ * its own panel.
  */
 export { ConnectClient, DEFAULT_BASE_URL, FlungConnectError } from './client.js';
+export { createConnectController, initialConnectState } from './controller.js';
 export { connectInPopup, readRedirectResult, withoutRedirectResult } from './flows.js';
-export { HANDLE_PROMPT, isPlatform, parsePlatformList, PLATFORM_NAMES, tokenPlatforms } from './platforms.js';
-export { PLATFORMS } from './types.js';
+export { DEFAULT_LABELS, formatLabel } from './labels.js';
+export { HANDLE_PROMPT, isConnectVariant, isPageAccount, isPlatform, parsePlatformList, PLATFORM_NAMES, tokenPlatforms } from './platforms.js';
+export { CONNECT_VARIANTS, PLATFORMS } from './types.js';

package/dist/core/labels.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Every word the panel shows, in English. Pass `labels` to put it in another language or say it your way; `{platform}`, `{account}`,
+ * `{message}`, `{date}` and `{count}` are filled in where a label has them.
+ */
+export interface ConnectLabels {
+    /** The panel's name for a screen reader. */
+    panel: string;
+    /** The button on a platform with no accounts yet. */
+    connect: string;
+    /** The button on a platform that already has an account. */
+    connectAnother: string;
+    /** The button beside an account that needs reconnecting. */
+    reconnect: string;
+    /** The button beside each account, and the one that confirms. */
+    disconnect: string;
+    /** The question before a disconnect. `{account}`. */
+    confirmDisconnect: string;
+    /** The button that keeps the account instead. */
+    keep: string;
+    /** Stops waiting, or closes a question. */
+    cancel: string;
+    /** Sends the Mastodon server or Bluesky handle. */
+    continue: string;
+    /** The Bluesky handle field's label. */
+    handleBluesky: string;
+    /** The Mastodon server field's label. */
+    handleMastodon: string;
+    /** While the sign-in window is open. `{platform}`. */
+    waiting: string;
+    /** When the browser refused to open the window. `{platform}`. */
+    blocked: string;
+    /** The link to the consent page when the window was blocked. `{platform}`. */
+    openSignIn: string;
+    /** After a connect. `{platform}`. */
+    connected: string;
+    /** After a connect that failed. `{platform}` and `{message}`. */
+    failed: string;
+    /** After a connect session ran out of time. `{platform}`. */
+    expired: string;
+    /** After a disconnect. `{account}`. */
+    disconnected: string;
+    /** Beside an account that must be reconnected. */
+    needsReconnect: string;
+    /** Beside an account whose connection ends soon. `{date}`. */
+    reconnectBy: string;
+    /** Under a platform's name once it has accounts. `{count}`. */
+    connectedCount: string;
+    /** Under a platform's name before it has any. */
+    notConnected: string;
+    /** Before Flung's name in the panel's footer, which `branding="none"` hides. */
+    securedBy: string;
+    /** While the accounts are read for the first time. */
+    loading: string;
+    /** When the accounts could not be read. `{message}`. */
+    loadFailed: string;
+    /** When there is no platform to offer. */
+    empty: string;
+    /** When the panel has no connect token. */
+    noToken: string;
+    /** The question above the choice between a profile and a page, when a platform offers both. `{platform}`. */
+    chooseVariant: string;
+    /** The choice that connects the person's own profile. */
+    variantPersonal: string;
+    /** The line under it. */
+    variantPersonalDescription: string;
+    /** The choice that connects the company pages the person administers. */
+    variantPages: string;
+    /** The line under it. */
+    variantPagesDescription: string;
+    /** The platform's name on its pages tile, with `variants="tiles"`, or when pages are all it can connect. `{platform}`. */
+    pagesName: string;
+    /** The small tag beside an account that is a company page, not a person. */
+    pageTag: string;
+}
+/** The panel's words in English. */
+export declare const DEFAULT_LABELS: ConnectLabels;
+/** Fills a label's `{name}` places from `values`, leaving any it has no value for as they are. The result is text, never markup. */
+export declare function formatLabel(template: string, values: Readonly<Record<string, string>>): string;

package/dist/core/labels.js

@@ -0,0 +1,41 @@
+/** The panel's words in English. */
+export const DEFAULT_LABELS = {
+    panel: 'Connected accounts',
+    connect: 'Connect',
+    connectAnother: 'Add another',
+    reconnect: 'Reconnect',
+    disconnect: 'Disconnect',
+    confirmDisconnect: 'Disconnect {account}? Posts to it will stop.',
+    keep: 'Keep it',
+    cancel: 'Cancel',
+    continue: 'Continue',
+    handleBluesky: 'Your Bluesky handle, such as alice.bsky.social (optional)',
+    handleMastodon: 'Your Mastodon server, such as mastodon.social',
+    waiting: 'Finish signing in to {platform} in the window that opened.',
+    blocked: 'Your browser did not open the {platform} window.',
+    openSignIn: 'Open {platform} sign-in',
+    connected: '{platform} is connected.',
+    failed: '{platform} was not connected: {message}',
+    expired: 'Signing in to {platform} took too long. Try again.',
+    disconnected: '{account} is disconnected.',
+    needsReconnect: 'Needs reconnecting',
+    reconnectBy: 'Reconnect by {date}',
+    connectedCount: '{count} connected',
+    notConnected: 'Not connected',
+    securedBy: 'Secured by',
+    loading: 'Loading accounts…',
+    loadFailed: 'Could not load accounts: {message}',
+    empty: 'There is nothing to connect here.',
+    noToken: 'This panel has no connect token yet.',
+    chooseVariant: 'What do you want to connect on {platform}?',
+    variantPersonal: 'Personal profile',
+    variantPersonalDescription: 'Post as yourself.',
+    variantPages: 'Company page',
+    variantPagesDescription: 'Post as a page you admin.',
+    pagesName: '{platform} Page',
+    pageTag: 'Page',
+};
+/** Fills a label's `{name}` places from `values`, leaving any it has no value for as they are. The result is text, never markup. */
+export function formatLabel(template, values) {
+    return template.replace(/\{(\w+)\}/g, (whole, name) => values[name] ?? whole);
+}

package/dist/core/platforms.d.ts

@@ -1,4 +1,4 @@
-import type { Platform } from './types.js';
+import type { Account, ConnectVariant, Platform } from './types.js';
 export declare const PLATFORM_NAMES: Readonly<Record<Platform, string>>;
 /** What a connect asks the person for first: Mastodon needs their instance; Bluesky takes a handle when they have one. */
 export declare const HANDLE_PROMPT: Readonly<Partial<Record<Platform, {
@@ -12,3 +12,9 @@ export declare function parsePlatformList(value: string | null | undefined): Pla
  * API checks the signature and refuses the rest. Null when the token names none or cannot be read.
  */
 export declare function tokenPlatforms(token: string): Platform[] | null;
+export declare function isConnectVariant(value: unknown): value is ConnectVariant;
+/**
+ * Whether an account is a company page rather than a person: a LinkedIn account that posts as an organisation
+ * (`urn:li:organization:<id>`), as the `pages` variant connects them.
+ */
+export declare function isPageAccount(account: Pick<Account, 'platform' | 'platformUserId'>): boolean;

package/dist/core/platforms.js

@@ -1,4 +1,4 @@
-import { PLATFORMS } from './types.js';
+import { CONNECT_VARIANTS, PLATFORMS } from './types.js';
 export const PLATFORM_NAMES = {
     x: 'X',
     instagram: 'Instagram',
@@ -47,3 +47,13 @@ export function tokenPlatforms(token) {
         return null;
     }
 }
+export function isConnectVariant(value) {
+    return typeof value === 'string' && CONNECT_VARIANTS.includes(value);
+}
+/**
+ * Whether an account is a company page rather than a person: a LinkedIn account that posts as an organisation
+ * (`urn:li:organization:<id>`), as the `pages` variant connects them.
+ */
+export function isPageAccount(account) {
+    return account.platform === 'linkedin' && account.platformUserId.startsWith('urn:li:organization:');
+}