@pontive/pontkit-core 1.0.0

package/dist/components/widgets/pont-signup/pont-signup.d.ts

@@ -0,0 +1,16 @@
+import { LitElement } from '../../../../node_modules/lit';
+import { BrandingEntitlements } from '../../../context';
+export declare class PontSignUp extends LitElement {
+    renderSpec: string | null;
+    branding: BrandingEntitlements;
+    locales: string;
+    createRenderRoot(): this;
+    private __flowStarted;
+    private __initialized;
+    private __previousLocale;
+    protected firstUpdated(): void;
+    protected updated(changedProperties: Map<string, unknown>): void;
+    private startAuthFlow;
+    private tryRemoveFallback;
+    render(): import('../../../../node_modules/lit-html').TemplateResult<1>;
+}

package/dist/components/wrappers/base-element/base-element.d.ts

@@ -0,0 +1,19 @@
+import { Style } from '../../../types/styles';
+import { LitElement } from '../../../../node_modules/lit';
+export declare abstract class BaseElement extends LitElement {
+    shadow: boolean;
+    constructor();
+    protected parseJsonAttribute<T = unknown>(attrName: string): T;
+    protected get sbStyle(): Style;
+    protected getAttributesToExclude(): string[];
+    protected getFilteredAttributes(): Record<string, string>;
+    protected isCustomPropertySet(property: string): boolean;
+    protected applyCustomClass(variables: string[], selector: string, className?: string): void;
+    protected moveAttributesToElement(target: HTMLElement, attributesToMove?: string[]): void;
+    protected removeAttributesFromHost(attributes?: string[]): void;
+    private __initialAttributesCache;
+    protected captureHostAttributes(): Record<string, string>;
+    protected getHostClass(): string;
+    protected removeDuplicateContent(): void;
+    protected moveLightDomChildrenInto(target: HTMLElement, specificNodes?: Node[]): void;
+}

package/dist/components/wrappers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './base-element/base-element';
+export * from './layout/layout';
+export * from './pont-provider/pont-provider';
+export * from './pont-signed-out/pont-signed-out';
+export * from './pont-signed-in/pont-signed-in';
+export * from './pont-authenticated/pont-authenticated';
+export * from './pont-auth-state/pont-auth-state';

package/dist/components/wrappers/layout/layout.d.ts

@@ -0,0 +1,57 @@
+import { LitElement } from '../../../../node_modules/lit';
+import { BrandingEntitlements } from '../../../context';
+export declare class PontKitLayout extends LitElement {
+    private spec;
+    set renderSpec(v: string);
+    /**
+     * Render every descendant as a representative example of itself rather than
+     * resolving it against runtime context (see context/design-context.ts).
+     *
+     * Provided here rather than on `pont-provider` because the screen designer's
+     * preview instantiates `pont-layout` directly — it has no provider ancestor —
+     * and `pont-layout` is also what the hosted page renders, so one declaration
+     * covers both. Elements injected into `#dynamic-content` via innerHTML are
+     * descendants of this host, so their context requests reach it normally.
+     */
+    designMode: boolean;
+    /**
+     * Account-level branding entitlements for this screen (see
+     * context/branding-context.ts).
+     *
+     * Provided here for the same reason as `designMode`: `pont-layout` is the one
+     * element every spec-rendered screen goes through, including the designer's
+     * preview, which has no `pont-provider` ancestor.
+     *
+     * `attribute: false` is deliberate. This is an object set imperatively from
+     * the backend response, on the same channel and with the same trust level as
+     * `renderSpec` — never authored in markup.
+     *
+     * NOTE: because this always provides a value, it SHADOWS any `pont-provider`
+     * above it. Widgets that render an `pont-layout` inside a provider must forward
+     * the entitlement explicitly, exactly as they forward `renderSpec`. Failing
+     * to forward it falls back to `DEFAULT_BRANDING`, i.e. the watermark shows.
+     */
+    branding: BrandingEntitlements;
+    createRenderRoot(): this;
+    updated(): void;
+    private renderDynamicContent;
+    /** Tags already reported on this page, so a re-render does not repeat them. */
+    private static reportedUnregistered;
+    /**
+     * The spec names an element this bundle does not define.
+     *
+     * This is the one signal in the system that the markup a server composed and
+     * the bundle a page loaded have drifted apart — a screen published against a
+     * newer vocabulary than the release serving it, or a bundle rolled back past
+     * a tag a screen already uses (pontive-spec/21-element-versioning-and-
+     * compatibility.md §6.3, §9.2). A console warning is invisible to anyone who
+     * could act on it, so it is also dispatched as `pont:unregistered-element` on
+     * `document` for the host page to forward to its telemetry. Once per tag per
+     * page: `updated()` runs on every Lit update and the same missing tag would
+     * otherwise report on each.
+     */
+    static readonly UNREGISTERED_ELEMENT_EVENT = "pont:unregistered-element";
+    private static reportUnregistered;
+    render(): import('../../../../node_modules/lit-html').TemplateResult<1>;
+    private handleError;
+}

package/dist/components/wrappers/pont-auth-state/pont-auth-state.d.ts

@@ -0,0 +1,12 @@
+import { LitElement, PropertyValues } from '../../../../node_modules/lit';
+import { AuthState } from '../../../context';
+export declare class AuthStateElement extends LitElement {
+    createRenderRoot(): this;
+    private _cachedChildren;
+    auth?: AuthState;
+    connectedCallback(): void;
+    private tryRemoveFallback;
+    private syncAuthChildren;
+    protected updated(_changedProperties: PropertyValues): void;
+    render(): import('../../../../node_modules/lit-html').TemplateResult<1>;
+}

package/dist/components/wrappers/pont-authenticated/pont-authenticated.d.ts

@@ -0,0 +1,27 @@
+import { LitElement, nothing } from '../../../../node_modules/lit';
+import { AuthState } from '../../../context';
+import { EnvConfig } from '../../../types';
+export declare class PontAuthenticated extends LitElement {
+    private _cachedChildren;
+    /**
+     * Children marked `slot="loading"`, shown while the provider is still asking
+     * whether this browser is signed in.
+     *
+     * A real <slot> is not available here — this element stays in the light DOM so
+     * host CSS reaches its children — so the children are partitioned on capture
+     * instead. The attribute is spelled `slot` anyway, because that is what an
+     * author expects to write and it means the same thing.
+     */
+    private _loadingChildren;
+    private _captured;
+    createRenderRoot(): this;
+    connectedCallback(): void;
+    /**
+     * The URL to redirect to if the user is not authenticated.
+     * Defaults to environment variable, can be overridden via property.
+     */
+    redirectUrl: string;
+    env: EnvConfig | null;
+    auth?: AuthState;
+    render(): import('../../../../node_modules/lit-html').TemplateResult<1> | typeof nothing;
+}

package/dist/components/wrappers/pont-provider/pont-provider.d.ts

@@ -0,0 +1,107 @@
+import { AuthState, BrandingEntitlements } from '../../../context';
+import { EnvConfig } from '../../../types';
+import { LitElement, PropertyValues } from '../../../../node_modules/lit';
+export declare class PontProvider extends LitElement {
+    createRenderRoot(): this;
+    env: EnvConfig | null;
+    locales?: string;
+    effectiveLocales: string;
+    auth: AuthState;
+    renderSpec: string | null;
+    branding: BrandingEntitlements;
+    autoRedirect: boolean;
+    setLocale(locales: string): void;
+    private _handleLocaleEvent;
+    private dispatchLocaleChangedEvent;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private readonly BRANDING_LINK_ID;
+    private getBrandingCssUrl;
+    private loadBrandingCss;
+    private configureAuth;
+    private updateLocaleAndAuth;
+    updated(changedProperties: PropertyValues): void;
+    private handleAuthStateChange;
+    /**
+     * sessionStorage, not localStorage: this is about one navigation in one tab.
+     * It must not outlive the tab, and it must not be visible to a second tab
+     * doing its own sign-in.
+     */
+    private readonly REDIRECT_ATTEMPT_KEY;
+    /**
+     * How recently a redirect must have been attempted for a return to this page
+     * to count as a bounce.
+     *
+     * A bounce is two server round trips, so it is fast — seconds at most. The
+     * window only needs to be wide enough to cover a slow one, and narrow enough
+     * that a user who legitimately navigates back here minutes later is not
+     * mistaken for one.
+     */
+    private readonly REDIRECT_BOUNCE_WINDOW_MS;
+    private recordRedirectAttempt;
+    private clearRedirectAttempt;
+    /**
+     * Reports whether we are here because `target` sent us back.
+     *
+     * Three things have to hold, and each rules out a way of arriving here that
+     * looks like a bounce but is not:
+     *
+     *   - a redirect to THIS target was recorded. A marker from some other
+     *     redirect is not evidence about this one.
+     *   - it was recent. Minutes later is a new visit, not a bounce.
+     *   - the browser navigated here. This is the one that matters: pressing Back
+     *     onto the sign-in page moments after a successful login, or reloading
+     *     it, produces a marker and a timestamp that are indistinguishable from a
+     *     bounce — and signing that user out would be a worse bug than the loop.
+     *     A server redirect chain is always `navigate`; Back is `back_forward`
+     *     and a reload is `reload`.
+     *
+     * The marker is consumed either way, so a stale one cannot go on being
+     * mistaken for evidence.
+     */
+    private wasBouncedBackFrom;
+    /**
+     * How the browser got to this page, per the Navigation Timing API. Anything
+     * unreadable reports "navigate", the conservative answer: it keeps the loop
+     * protection working on a browser that will not tell us, at the cost of the
+     * Back-button case we cannot detect there anyway.
+     */
+    private getNavigationType;
+    private refreshAuthState;
+    /**
+     * Publishes the auth state to anything that is not a Lit context consumer.
+     *
+     * The elements read `auth` through `@consume({ context: authContext })`, which
+     * is invisible from outside the custom element tree — a React host has no way
+     * in. It cannot ask `Auth` for this either: `resolved` means "restoreSession()
+     * has come back", which is this provider's knowledge and not the SDK's. Auth
+     * has no idea whether anyone has called it, and a second caller racing this
+     * one to find out would be a bug rather than an answer.
+     *
+     * So the state goes out as a DOM event as well, from the one method that
+     * writes it. The React wrapper in @pontive/pontkit-react listens for this and
+     * republishes it as React context, which is what lets `<SignedIn>` be an
+     * ordinary conditional instead of an element that takes its children into
+     * custody.
+     *
+     * `detail` is a copy. Handing out the live object would let a listener mutate
+     * the state every element on the page is reading.
+     */
+    private dispatchAuthChangedEvent;
+    /**
+     * Asks the authorization server whether this browser is already signed in,
+     * before settling on an answer.
+     *
+     * Auth.isAuthenticated() only reads what the SDK holds in memory or in
+     * localStorage. An app whose refresh token is delivered as an HttpOnly cookie
+     * has neither on a fresh page — the token is in the cookie, where no script
+     * can see it — so answering from local state alone reports every reload and
+     * every post-sign-in redirect as a sign-out. restoreSession() is what turns
+     * that cookie back into a session.
+     *
+     * Deliberately awaited before the state is published: a provider that said
+     * "signed out" first and corrected itself a moment later would send
+     * <pont-authenticated> redirecting to the sign-in page in between.
+     */
+    private restoreThenRefreshAuthState;
+}

package/dist/components/wrappers/pont-signed-in/pont-signed-in.d.ts

@@ -0,0 +1,11 @@
+import { LitElement, PropertyValues } from '../../../../node_modules/lit';
+import { AuthState } from '../../../context';
+export declare class SignedIn extends LitElement {
+    private _cachedChildren;
+    createRenderRoot(): this;
+    connectedCallback(): void;
+    auth?: AuthState;
+    private tryRemoveFallback;
+    protected updated(_changedProperties: PropertyValues): void;
+    render(): import('../../../../node_modules/lit-html').TemplateResult<1>;
+}

package/dist/components/wrappers/pont-signed-out/pont-signed-out.d.ts

@@ -0,0 +1,11 @@
+import { LitElement, PropertyValues } from '../../../../node_modules/lit';
+import { AuthState } from '../../../context';
+export declare class SignedOut extends LitElement {
+    private _cachedChildren;
+    createRenderRoot(): this;
+    auth?: AuthState;
+    connectedCallback(): void;
+    private tryRemoveFallback;
+    protected updated(_changedProperties: PropertyValues): void;
+    render(): import('../../../../node_modules/lit-html').TemplateResult<1>;
+}

package/dist/constants/classes.d.ts

@@ -0,0 +1,9 @@
+export declare const dashboardWidthClass = "pont-account-settings-dashboard-width";
+export declare const modalWidthClass = "pont-account-settings-modal-width";
+export declare const modalContainerClass = "pont-account-settings-modal-container";
+export declare const dashboardClass = "pont-account-settings-dashboard";
+export declare const pageClasses = "pont-account-settings-page-reset-margin";
+export declare const modalClasses = "pont-account-settings-modal-root";
+export declare const tabTriggerClass = "pont-account-settings-tab-trigger";
+export declare const horizontalTabClass = "pont-account-settings-horizontal-tab-list";
+export declare const verticalTabClass = "pont-account-settings-vertical-tab-list";

package/dist/constants/components.d.ts

@@ -0,0 +1,6 @@
+export declare const NAMESPACE = "sb";
+export declare const BREAKPOINTS: {
+    readonly xs: 640;
+    readonly sm: 768;
+    readonly md: number;
+};

package/dist/constants/index.d.ts

@@ -0,0 +1,4 @@
+export * from './classes';
+export * from './components';
+export * from './regex';
+export * from './styles';

package/dist/constants/regex.d.ts

@@ -0,0 +1,4 @@
+export declare const PHONE_REGEX: RegExp;
+export declare const EMAIL_REGEX: RegExp;
+export declare const DATE_REGEX: RegExp;
+export declare const DATETIME_REGEX: RegExp;

package/dist/constants/styles.d.ts

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

package/dist/context/auth-context.d.ts

@@ -0,0 +1,17 @@
+export interface AuthState {
+    isAuthenticated: boolean;
+    /**
+     * Whether isAuthenticated is an answer yet.
+     *
+     * On a fresh page the provider has to ask the authorization server before it
+     * knows: an app using HttpOnly cookie refresh-token delivery holds nothing
+     * locally, so local state says "signed out" for every user until the cookie
+     * has been tried. Anything that navigates on isAuthenticated — pont-authenticated
+     * in particular — must wait for this rather than acting on the interim answer,
+     * or every reload bounces a signed-in user to the sign-in page.
+     */
+    resolved: boolean;
+}
+export declare const authContext: {
+    __context__: AuthState;
+};

package/dist/context/branding-context.d.ts

@@ -0,0 +1,52 @@
+import { ReactiveControllerHost, ReactiveElement } from '../../node_modules/lit';
+/**
+ * Account-level branding entitlements: what a project's plan permits it to
+ * change about Pontive's own branding on a rendered screen.
+ *
+ * These are NOT authoring input. A screen author cannot grant themselves
+ * white-labelling by editing a screen in the designer, and no element exposes
+ * an attribute or public property for them — the value is resolved by the
+ * backend per request and flows down as context. An element that renders
+ * branding ASKS for the entitlement; it is never TOLD by its own markup.
+ *
+ * This is an API-integrity guarantee, not a security boundary: everything here
+ * renders in light DOM, so any watermark can be deleted from devtools. The
+ * point is that there is no supported, discoverable, semver-stable way for a
+ * consumer to switch it off. Commercial enforcement lives on the server (which
+ * simply does not emit the entitlement) and in the licence terms.
+ *
+ * See docs/branding-entitlements.md.
+ */
+export interface BrandingEntitlements {
+    /** Whether the Pontive watermark must be rendered on the screen shell. */
+    showWatermark: boolean;
+}
+/**
+ * Fail closed. A missing provider, a dropped wire, or a backend that has not
+ * been taught about entitlements yet must all land on "watermark shows" — the
+ * default must never silently unlock a paid feature.
+ */
+export declare const DEFAULT_BRANDING: BrandingEntitlements;
+export declare const brandingContext: {
+    __context__: BrandingEntitlements;
+};
+/**
+ * Reads branding entitlements for one element.
+ *
+ * A controller rather than a base class or mixin for the same reason as
+ * `DesignModeController`: the elements that render branding do not share an
+ * ancestor.
+ *
+ * Deliberately unlike `DesignModeController`, there is NO attribute escape
+ * hatch. Design mode is an authoring signal, so letting a `design-mode`
+ * attribute win is legitimate. An entitlement is a commercial fact, and an
+ * override attribute would reintroduce exactly the hole this design closes.
+ * Storybook and standalone demos get the value by providing the context (see
+ * block.stories.ts), not by setting an attribute.
+ */
+export declare class BrandingController {
+    private consumer;
+    constructor(host: ReactiveElement & ReactiveControllerHost);
+    /** Whether this element must render the Pontive watermark. */
+    get showWatermark(): boolean;
+}

package/dist/context/customization-context.d.ts

@@ -0,0 +1,4 @@
+import { ICustomizations } from '../types';
+export declare const customizationsContext: {
+    __context__: ICustomizations | null;
+};

package/dist/context/design-context.d.ts

@@ -0,0 +1,47 @@
+import { ReactiveControllerHost, ReactiveElement } from '../../node_modules/lit';
+/**
+ * Design mode: the element is being placed in the screen designer's canvas,
+ * not served to an end user.
+ *
+ * Resolution — turning configured providers into buttons, narrowing identifier
+ * lists, injecting a brand logo, pruning what an app cannot use — is a RUNTIME
+ * concern. It has two consumers: the hosted sign-in page and the designer's
+ * Test mode. Design mode is neither. An author dragging an element onto the
+ * canvas wants to see what that element IS, and no context exists to resolve
+ * against anyway.
+ *
+ * Without this flag, context-dependent elements render their empty state,
+ * which is not neutral — it is wrong. A bare `pont-provider-field` renders an
+ * empty container and a bare `pont-logo` renders a broken image, so the author's
+ * first impression of the element they just placed is that it is broken.
+ *
+ * In design mode an element MUST render a representative example of itself.
+ * It must NOT prune itself, inject real project configuration, or substitute
+ * placeholders — `{{email}}` stays visible as a token so the author can see it
+ * is one.
+ *
+ * See pontive-spec/17-authflow-screen-resolution.md §1.
+ */
+export declare const designModeContext: {
+    __context__: boolean;
+};
+/**
+ * Reads design mode for one element.
+ *
+ * A controller rather than a base class or mixin because the elements that
+ * need it do not share an ancestor: `pont-logo` extends BaseElement while
+ * `pont-provider-field`, `pont-provider-button` and the field elements extend
+ * LitElement directly.
+ *
+ * Precedence: an explicit `design-mode` attribute on the element wins, so a
+ * Storybook story or a standalone demo can show the design rendering without
+ * standing up a provider. Otherwise the value comes from the nearest provider
+ * (`pont-layout`), which is how the designer canvas drives it.
+ */
+export declare class DesignModeController {
+    private host;
+    private consumer;
+    constructor(host: ReactiveElement & ReactiveControllerHost);
+    /** Whether this element should render its design-mode example. */
+    get active(): boolean;
+}

package/dist/context/env-context.d.ts

@@ -0,0 +1,4 @@
+import { EnvConfig } from '../types';
+export declare const envContext: {
+    __context__: EnvConfig | null;
+};

package/dist/context/index.d.ts

@@ -0,0 +1,8 @@
+export * from './auth-context';
+export * from './branding-context';
+export * from './customization-context';
+export * from './design-context';
+export * from './env-context';
+export * from './render-spec';
+export * from './user-context';
+export * from './locale-context';

package/dist/context/locale-context.d.ts

@@ -0,0 +1,3 @@
+export declare const localeContext: {
+    __context__: string;
+};

package/dist/context/render-spec.d.ts

@@ -0,0 +1,3 @@
+export declare const renderSpecContext: {
+    __context__: string | null;
+};

package/dist/context/user-context.d.ts

@@ -0,0 +1,8 @@
+import { User } from '../types';
+export interface UserContextValue {
+    user: User | null;
+    identifier: string | null;
+}
+export declare const userContext: {
+    __context__: UserContextValue;
+};

package/dist/events/account-settings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Opens the account settings modal if the component is in modal mode.
+ * Dispatches a global event that the component listens to.
+ */
+export declare function openAccountSettingsModal(): void;
+/**
+ * Closes the account settings modal if the component is in modal mode.
+ * Dispatches a global event that the component listens to.
+ */
+export declare function closeAccountSettingsModal(): void;

package/dist/events/index.d.ts

@@ -0,0 +1,15 @@
+import { closeAccountSettingsModal, openAccountSettingsModal } from './account-settings';
+import { closeMemberManagementModal, openMemberManagementModal } from './member-management';
+import { setLocales } from './locales';
+export { closeAccountSettingsModal, closeMemberManagementModal, openAccountSettingsModal, openMemberManagementModal, setLocales, };
+declare global {
+    interface Window {
+        __pontCoreSdk: {
+            setLocales?: (locales: string) => void;
+            openMemberManagementModal?: () => void;
+            closeMemberManagementModal?: () => void;
+            openAccountSettingsModal?: () => void;
+            closeAccountSettingsModal?: () => void;
+        };
+    }
+}

package/dist/events/locales.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Set the SDK's locales by dispatching a global event.
+ * The `<pont-provider>` listens for this event and updates its locales.
+ * @param locales - The new locales code (e.g., 'fr', 'de').
+ */
+export declare function setLocales(locales: string): void;

package/dist/events/member-management.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Opens the account settings modal if the component is in modal mode.
+ * Dispatches a global event that the component listens to.
+ */
+export declare function openMemberManagementModal(): void;
+/**
+ * Closes the account settings modal if the component is in modal mode.
+ * Dispatches a global event that the component listens to.
+ */
+export declare function closeMemberManagementModal(): void;

package/dist/funcs/env.d.ts

@@ -0,0 +1,3 @@
+import { EnvConfig } from '../types';
+export declare function initSdk(config: EnvConfig): void;
+export declare function getEnvConfig(): EnvConfig | null;

package/dist/funcs/index.d.ts

@@ -0,0 +1 @@
+export * from './env';

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './components/wrappers';
+export * from './components/widgets';
+export * from './components/ui';
+export * from './components/renderers';
+export * from './events';
+export declare function useAuthProvider(): import('@pontive/oidc-client').AuthService;