@globalpayments-private/gpds-pattern-web 0.0.0-stage → 0.1.0-pr.7.gdcb74cd

package/dist/esm/index.js

@@ -0,0 +1,170 @@
+export { D as DEFAULT_LOGIN_LABELS, c as createControlStrategy, a as fail, f as formatLabel, g as goTo, s as stay } from './control-strategy-DOrg55po.js';
+
+/**
+ * Provider contracts for the GP pattern library.
+ *
+ * A pattern owns the *workflow* — which step comes next, what is in flight,
+ * what the user is told when something fails. It owns no SDK code and knows no
+ * identity platform. The seam between the two is a Provider contract: the
+ * consumer brings their own backend SDK (Okta, Auth0, Cognito, Ping, GCP API
+ * Gateway, Azure APIM, …) and writes a thin adapter against the interface
+ * below.
+ *
+ * See `docs/adr/0002-provider-driven-patterns.md` for why the workflow lives
+ * inside the pattern rather than in the host application.
+ */
+/**
+ * Identity helper that gives adapter authors type inference and a single place
+ * to add shared behaviour later (telemetry, retry, logging) without changing
+ * every call site.
+ *
+ * ```ts
+ * const auth = createAuthProvider({
+ *   signIn: ({ identifier, password }) => oktaSdk.authn(identifier, password),
+ *   verifyOtp: ({ code }) => oktaSdk.verifyFactor(code),
+ * });
+ * ```
+ */
+function createAuthProvider(provider) {
+    return provider;
+}
+
+const DEFAULT_USER = {
+    identifier: 'ada@example.com',
+    password: 'correct-horse',
+    mfaMethods: [
+        { id: 'app', label: 'Authenticator app', description: 'Use the code from your authenticator app' },
+        { id: 'sms', label: 'Text message', description: 'Ending in ••3312' },
+    ],
+    otpCode: '555555',
+};
+/**
+ * An in-memory reference implementation of {@link UdsAuthProvider}.
+ *
+ * It exists so the demo harness and the test suite can drive the *real*
+ * workflow — identifier → password → MFA choice → OTP → success, plus the
+ * recovery, lockout and sign-up branches — without a network or an identity
+ * platform. It is also the worked example adapter authors copy from.
+ *
+ * Not intended for production use: it compares passwords in plain text.
+ */
+function createMemoryAuthProvider(options = {}) {
+    const users = options.users ?? [DEFAULT_USER];
+    const maxAttempts = options.maxAttempts ?? 3;
+    const resendAfterMs = options.resendAfterMs ?? 30000;
+    const caps = {
+        signUp: true,
+        requestPasswordReset: true,
+        requestUsernameReminder: true,
+        resendOtp: true,
+        ...options.capabilities,
+    };
+    // Server-side state of the in-flight attempt.
+    let pending;
+    let failures = 0;
+    let locked = false;
+    const find = (identifier) => users.find(u => u.identifier.toLowerCase() === identifier.trim().toLowerCase());
+    const afterPassword = (user) => {
+        failures = 0;
+        if (user.mustResetPassword) {
+            return { status: 'password_reset_required' };
+        }
+        if (user.mfaMethods?.length) {
+            return { status: 'mfa_required', methods: user.mfaMethods };
+        }
+        return { status: 'success', session: { identifier: user.identifier } };
+    };
+    const provider = {
+        async signIn({ identifier, password }) {
+            if (locked) {
+                return { status: 'locked' };
+            }
+            const user = find(identifier);
+            if (!user) {
+                return { status: 'error', code: 'account_not_found' };
+            }
+            pending = user;
+            // Identifier-first: no password supplied yet.
+            if (password === undefined) {
+                return { status: 'password_required' };
+            }
+            return provider.verifyPassword({ identifier, password });
+        },
+        async verifyPassword({ password }) {
+            if (locked) {
+                return { status: 'locked' };
+            }
+            if (!pending) {
+                return { status: 'error', code: 'unknown' };
+            }
+            if (password !== pending.password) {
+                failures += 1;
+                if (failures >= maxAttempts) {
+                    locked = true;
+                    return { status: 'locked', unlockAfterMs: 15 * 60000 };
+                }
+                return { status: 'error', code: 'invalid_credentials' };
+            }
+            return afterPassword(pending);
+        },
+        async selectMfaMethod({ methodId }) {
+            const method = pending?.mfaMethods?.find(m => m.id === methodId);
+            return { status: 'otp_required', method, codeLength: 6, resendAfterMs };
+        },
+        async verifyOtp({ code }) {
+            if (code !== (pending?.otpCode ?? DEFAULT_USER.otpCode)) {
+                failures += 1;
+                if (failures >= maxAttempts) {
+                    locked = true;
+                    return { status: 'locked' };
+                }
+                return { status: 'error', code: 'invalid_code' };
+            }
+            failures = 0;
+            return { status: 'success', session: { identifier: pending?.identifier } };
+        },
+        async resetPassword({ password }) {
+            if (password.length < 8) {
+                return { status: 'error', code: 'password_policy' };
+            }
+            if (pending) {
+                pending.password = password;
+                pending.mustResetPassword = false;
+            }
+            return { status: 'success', session: { identifier: pending?.identifier } };
+        },
+    };
+    if (caps.resendOtp) {
+        provider.resendOtp = async () => ({ status: 'otp_required', codeLength: 6, resendAfterMs });
+    }
+    if (caps.requestPasswordReset) {
+        provider.requestPasswordReset = async ({ identifier }) => {
+            const user = find(identifier);
+            return user
+                ? { status: 'reset_link_sent', destination: user.identifier }
+                : { status: 'error', code: 'account_not_found' };
+        };
+    }
+    if (caps.requestUsernameReminder) {
+        provider.requestUsernameReminder = async ({ email }) => ({ status: 'username_sent', destination: email });
+    }
+    if (caps.signUp) {
+        provider.signUp = async ({ firstName, lastName, identifier }) => {
+            if (find(identifier)) {
+                return { status: 'error', code: 'account_exists' };
+            }
+            const user = { identifier, password: '', otpCode: DEFAULT_USER.otpCode };
+            users.push(user);
+            pending = user;
+            return { status: 'success', session: { identifier, firstName, lastName } };
+        };
+    }
+    return createAuthProvider(provider);
+}
+
+/** Identity helper giving a config literal its types without an annotation. */
+function createLoginConfig(config) {
+    return config;
+}
+
+export { createAuthProvider, createLoginConfig, createMemoryAuthProvider };

package/dist/esm/loader.js

@@ -0,0 +1,10 @@
+import { g as globalScripts, b as bootstrapLazy } from './index-DsXlLyGj.js';
+export { s as setNonce } from './index-DsXlLyGj.js';
+
+const defineCustomElements = async (win, options) => {
+  if (typeof window === 'undefined') return undefined;
+  await globalScripts();
+  return bootstrapLazy([["uds-pattern-login-card_2",[[257,"uds-pattern-login-card",{"config":[1],"initialStep":[1,"initial-step"],"identifier":[1],"otpLength":[2,"otp-length"],"rememberStorageKey":[1,"remember-storage-key"],"showHelpFooter":[4,"show-help-footer"],"step":[32],"busy":[32],"errorText":[32],"methods":[32],"otpMethodLabel":[32],"destination":[32],"unlockMinutes":[32],"resendAt":[32],"nowTick":[32],"values":[32],"reset":[64]}],[257,"uds-pattern-login-page",{"logoSrc":[1,"logo-src"],"logoAlt":[1,"logo-alt"],"logoHref":[1,"logo-href"]}]]]], options);
+};
+
+export { defineCustomElements };