@memberstack/dom 2.0.1 → 2.0.2

package/lib/{types/utils/payloads.d.mts → models-CFT_ABd5.d.ts}

@@ -114,9 +114,7 @@ declare namespace Payload {
             redirect: string;
             contentGroups?: Transforms["RestrictedUrlGroup"][];
         };
-        MemberJSON: {
-            json: object;
-        };
+        MemberJSON: object;
         AuthProviders: {
             providers: {
                 provider: string;
@@ -137,8 +135,8 @@ declare namespace Payload {
             loginRedirect: string;
             stripeCustomerId: string;
             createdAt: string;
-            metaData: object;
-            customFields: object;
+            metaData: Record<string, unknown>;
+            customFields: Record<string, unknown>;
             permissions: string[] | [];
             planConnections: Transforms["MemberPlanConnection"][];
         };
@@ -296,4 +294,194 @@ declare namespace Payload {
     }
 }
 
-export { Payload };
+/**
+ * @fileoverview Convenience type exports for Memberstack SDK.
+ * These types provide direct access to core data models without needing
+ * to navigate the Payload.Transforms namespace.
+ *
+ * @example
+ * ```typescript
+ * import type { Member, Plan, PlanConnection } from '@memberstack/dom';
+ *
+ * function displayMember(member: Member) {
+ *   console.log(member.auth.email);
+ * }
+ * ```
+ */
+
+/**
+ * A Memberstack member (authenticated user).
+ *
+ * @example
+ * ```typescript
+ * const { data: member } = await memberstack.getCurrentMember();
+ * if (member) {
+ *   console.log('Email:', member.auth.email);
+ *   console.log('Verified:', member.verified);
+ *   console.log('Plans:', member.planConnections.map(p => p.planId));
+ * }
+ * ```
+ */
+type Member = Payload.Transforms["Member"];
+/**
+ * A membership plan in your Memberstack app.
+ *
+ * @example
+ * ```typescript
+ * const { data: plans } = await memberstack.getPlans();
+ * plans.forEach((plan: Plan) => {
+ *   console.log(`${plan.name}: ${plan.prices?.[0]?.amount}`);
+ * });
+ * ```
+ */
+type Plan = Payload.Transforms["Plan"];
+/**
+ * A price option for a plan (monthly, yearly, etc.).
+ *
+ * @example
+ * ```typescript
+ * const plan = plans[0];
+ * plan.prices?.forEach((price: Price) => {
+ *   console.log(`${price.name}: ${price.amount} ${price.currency}/${price.interval.type}`);
+ * });
+ * ```
+ */
+type Price = Payload.Transforms["Price"];
+/**
+ * A member's connection to a plan (subscription or one-time purchase).
+ *
+ * @example
+ * ```typescript
+ * const activePlans = member.planConnections.filter(
+ *   (conn: PlanConnection) => conn.active
+ * );
+ * ```
+ */
+type PlanConnection = Payload.Transforms["MemberPlanConnection"];
+/**
+ * A content group that restricts access to URLs.
+ *
+ * @example
+ * ```typescript
+ * const { data: groups } = await memberstack.getRestrictedUrlGroups();
+ * const accessibleGroups = groups.filter(
+ *   (g: ContentGroup) => g.activeMemberHasAccess
+ * );
+ * ```
+ */
+type ContentGroup = Payload.Transforms["RestrictedUrlGroup"];
+/**
+ * App configuration and settings.
+ *
+ * @example
+ * ```typescript
+ * const { data: app } = await memberstack.getApp();
+ * console.log('App:', app.name);
+ * console.log('Mode:', app.mode); // 'live' or 'sandbox'
+ * ```
+ */
+type App = Payload.Transforms["App"];
+/**
+ * Authentication provider configuration (Google, Facebook, etc.).
+ */
+type AuthProvider = Payload.Transforms["AuthProvider"];
+/**
+ * Authentication response with tokens and member data.
+ */
+type MemberAuth = Payload.Transforms["MemberAuth"];
+/**
+ * Auth tokens returned after login/signup.
+ */
+type AuthTokens = MemberAuth["tokens"];
+/**
+ * A saved payment card for a member.
+ *
+ * @example
+ * ```typescript
+ * const { data: cards } = await memberstack.getMemberCards();
+ * const defaultCard = cards.find((card: MemberCard) => card.default);
+ * ```
+ */
+type MemberCard = Payload.Transforms["MemberCard"];
+/**
+ * An invoice for a member's subscription.
+ */
+type MemberInvoice = Payload.Transforms["MemberInvoice"];
+/**
+ * A payment receipt.
+ */
+type MemberReceipt = Payload.Transforms["MemberReceipt"];
+/**
+ * Checkout total calculation including taxes and fees.
+ */
+type CheckoutTotal = Payload.Transforms["TotalCheckoutAmount"];
+/**
+ * Gated content returned by getSecureContent().
+ */
+type SecureContent = Payload.Transforms["SecureContent"];
+/**
+ * A custom field defined in your Memberstack app.
+ */
+type CustomField = Payload.Transforms["CustomField"];
+/**
+ * App branding configuration.
+ */
+type Branding = Payload.Transforms["Branding"];
+/**
+ * A community post.
+ */
+type Post = Payload.Transforms["Post"];
+/**
+ * A thread/reply on a post.
+ */
+type Thread = Payload.Transforms["Thread"];
+/**
+ * Extract the data type from a Memberstack SDK response.
+ *
+ * @example
+ * ```typescript
+ * import type { ExtractData, GetCurrentMemberPayload } from '@memberstack/dom';
+ *
+ * // Get the member type from the response
+ * type MemberData = ExtractData<GetCurrentMemberPayload>;
+ * // MemberData = Member | null
+ * ```
+ */
+type ExtractData<T> = T extends {
+    data: infer D;
+} ? D : never;
+/**
+ * Generic paginated response shape.
+ *
+ * @example
+ * ```typescript
+ * type InvoicesPage = PaginatedData<MemberInvoice>;
+ * // { data: MemberInvoice[], hasNext: boolean, endCursor: string | null, totalCount: number }
+ * ```
+ */
+type PaginatedData<T> = {
+    data: T[];
+    hasNext: boolean;
+    endCursor: string | null;
+    totalCount: number;
+};
+/**
+ * Common member fields for display purposes.
+ *
+ * @example
+ * ```typescript
+ * function getMemberDisplayInfo(member: Member): MemberDisplayInfo {
+ *   return {
+ *     id: member.id,
+ *     email: member.auth.email,
+ *     profileImage: member.profileImage,
+ *     verified: member.verified,
+ *   };
+ * }
+ * ```
+ */
+type MemberDisplayInfo = Pick<Member, 'id' | 'profileImage' | 'verified'> & {
+    email: string;
+};
+
+export { type App as A, type Branding as B, type ContentGroup as C, type ExtractData as E, type Member as M, Payload as P, type SecureContent as S, type Thread as T, type Plan as a, type Price as b, type PlanConnection as c, type AuthProvider as d, type MemberAuth as e, type AuthTokens as f, type MemberCard as g, type MemberInvoice as h, type MemberReceipt as i, type CheckoutTotal as j, type CustomField as k, type Post as l, type PaginatedData as m, type MemberDisplayInfo as n };

package/lib/testing/index.d.mts

@@ -0,0 +1,295 @@
+import { M as Member, a as Plan, c as PlanConnection, g as MemberCard, b as Price, A as App, C as ContentGroup } from '../models-CFT_ABd5.js';
+
+/**
+ * @fileoverview Test utilities for Memberstack SDK.
+ * Provides mock factories and helpers for testing applications that use Memberstack.
+ *
+ * @example
+ * ```typescript
+ * import { createMockMemberstack, mockMember, mockPlan } from '@memberstack/dom/testing';
+ *
+ * // Create a mock SDK instance
+ * const mockMs = createMockMemberstack({
+ *   member: mockMember({ email: 'test@example.com' }),
+ *   plans: [mockPlan({ name: 'Pro' })]
+ * });
+ *
+ * // Use in tests
+ * const { data: member } = await mockMs.getCurrentMember();
+ * expect(member?.auth.email).toBe('test@example.com');
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Creates a mock member object with sensible defaults.
+ * Override any property by passing it in the options.
+ *
+ * @param overrides - Partial member data to override defaults
+ * @returns A complete mock Member object
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const member = mockMember();
+ *
+ * // With custom email
+ * const member = mockMember({ auth: { email: 'custom@test.com' } });
+ *
+ * // With plans
+ * const member = mockMember({
+ *   planConnections: [mockPlanConnection({ planId: 'pln_abc123' })]
+ * });
+ * ```
+ */
+declare function mockMember(overrides?: DeepPartial<Member>): Member;
+/**
+ * Creates a mock plan object.
+ *
+ * @param overrides - Partial plan data to override defaults
+ * @returns A complete mock Plan object
+ *
+ * @example
+ * ```typescript
+ * const freePlan = mockPlan({ name: 'Free', prices: [] });
+ * const proPlan = mockPlan({
+ *   name: 'Pro',
+ *   prices: [mockPrice({ amount: '9.99' })]
+ * });
+ * ```
+ */
+declare function mockPlan(overrides?: DeepPartial<Plan>): Plan;
+/**
+ * Creates a mock plan connection (member's subscription to a plan).
+ *
+ * @param overrides - Partial connection data to override defaults
+ * @returns A complete mock PlanConnection object
+ *
+ * @example
+ * ```typescript
+ * // Active subscription
+ * const conn = mockPlanConnection({ active: true, status: 'ACTIVE' });
+ *
+ * // Canceled subscription
+ * const conn = mockPlanConnection({
+ *   active: false,
+ *   status: 'CANCELED',
+ *   payment: { cancelAtDate: Date.now() + 86400000 }
+ * });
+ * ```
+ */
+declare function mockPlanConnection(overrides?: DeepPartial<PlanConnection>): PlanConnection;
+/**
+ * Creates a mock payment card.
+ *
+ * @param overrides - Partial card data to override defaults
+ * @returns A complete mock MemberCard object
+ */
+declare function mockCard(overrides?: DeepPartial<MemberCard>): MemberCard;
+/**
+ * Creates a mock price object for a plan.
+ *
+ * @param overrides - Partial price data to override defaults
+ * @returns A complete mock Price object
+ *
+ * @example
+ * ```typescript
+ * const monthlyPrice = mockPrice({ amount: '9.99', name: 'Monthly' });
+ * const yearlyPrice = mockPrice({
+ *   amount: '99.99',
+ *   name: 'Yearly',
+ *   interval: { type: 'year', count: 1 }
+ * });
+ * ```
+ */
+declare function mockPrice(overrides?: DeepPartial<Price>): Price;
+/**
+ * Creates a mock app configuration.
+ *
+ * @param overrides - Partial app data to override defaults
+ * @returns A complete mock App object
+ */
+declare function mockApp(overrides?: DeepPartial<App>): App;
+/**
+ * Creates a mock content group (restricted URL group).
+ *
+ * @param overrides - Partial group data to override defaults
+ * @returns A complete mock ContentGroup object
+ */
+declare function mockContentGroup(overrides?: DeepPartial<ContentGroup>): ContentGroup;
+/**
+ * Options for creating a mock Memberstack instance.
+ */
+interface MockMemberstackOptions {
+    /** The currently logged-in member, or null if logged out */
+    member?: Member | null;
+    /** Available plans in the app */
+    plans?: Plan[];
+    /** App configuration */
+    app?: App;
+    /** Content groups */
+    contentGroups?: ContentGroup[];
+    /** Member's saved cards */
+    cards?: MemberCard[];
+    /** Custom method overrides */
+    overrides?: Partial<MockMemberstackInstance>;
+}
+/**
+ * Mock implementation of the Memberstack SDK.
+ * Implements the most commonly used methods for testing.
+ */
+interface MockMemberstackInstance {
+    getCurrentMember: () => Promise<{
+        data: Member | null;
+    }>;
+    getPlans: () => Promise<{
+        data: Plan[];
+    }>;
+    getPlan: (params: {
+        planId: string;
+    }) => Promise<{
+        data: Plan | null;
+    }>;
+    getApp: () => Promise<{
+        data: App;
+    }>;
+    getRestrictedUrlGroups: () => Promise<{
+        data: ContentGroup[];
+    }>;
+    getMemberCards: () => Promise<{
+        data: MemberCard[];
+    }>;
+    loginMemberEmailPassword: (params: {
+        email: string;
+        password: string;
+    }) => Promise<{
+        data: {
+            member: Member;
+            tokens: {
+                accessToken: string;
+                expires: number;
+                type: string;
+            };
+            redirect: string;
+        };
+    }>;
+    signupMemberEmailPassword: (params: {
+        email: string;
+        password: string;
+    }) => Promise<{
+        data: {
+            member: Member;
+            tokens: {
+                accessToken: string;
+                expires: number;
+                type: string;
+            };
+            redirect: string;
+        };
+    }>;
+    logout: () => Promise<{
+        data: {
+            redirect?: string;
+        };
+    }>;
+    updateMember: (params: {
+        customFields?: object;
+    }) => Promise<{
+        data: Member;
+    }>;
+    onAuthChange: (callback: (payload: {
+        member: Member | null;
+    }) => void) => () => void;
+    _setMember: (member: Member | null) => void;
+    _getMockState: () => {
+        member: Member | null;
+        plans: Plan[];
+        app: App;
+    };
+}
+/**
+ * Creates a mock Memberstack SDK instance for testing.
+ * All methods return promises with mock data based on the provided options.
+ *
+ * @param options - Configuration for the mock instance
+ * @returns A mock Memberstack instance with common methods
+ *
+ * @example
+ * ```typescript
+ * // Basic setup
+ * const mockMs = createMockMemberstack({
+ *   member: mockMember({ auth: { email: 'test@test.com' } }),
+ *   plans: [mockPlan({ name: 'Free' }), mockPlan({ name: 'Pro' })]
+ * });
+ *
+ * // Use in component tests
+ * const { data: member } = await mockMs.getCurrentMember();
+ * expect(member).not.toBeNull();
+ *
+ * // Test logout flow
+ * await mockMs.logout();
+ * const { data: afterLogout } = await mockMs.getCurrentMember();
+ * expect(afterLogout).toBeNull();
+ *
+ * // Subscribe to auth changes
+ * const authCallback = jest.fn();
+ * mockMs.onAuthChange(authCallback);
+ * mockMs._setMember(null); // Simulate logout
+ * expect(authCallback).toHaveBeenCalledWith({ member: null });
+ * ```
+ */
+declare function createMockMemberstack(options?: MockMemberstackOptions): MockMemberstackInstance;
+/** Deep partial type for nested object overrides */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Custom matchers for testing Memberstack data.
+ * These can be extended with Jest's expect.extend() or Vitest's expect.extend().
+ *
+ * @example
+ * ```typescript
+ * // In your test setup file:
+ * import { memberstackMatchers } from '@memberstack/dom/testing';
+ * expect.extend(memberstackMatchers);
+ *
+ * // In tests:
+ * expect(member).toBeLoggedIn();
+ * expect(member).toHavePlan('pln_abc123');
+ * ```
+ */
+declare const memberstackMatchers: {
+    /**
+     * Assert that a member is logged in (not null and has an email).
+     */
+    toBeLoggedIn(received: Member | null): {
+        pass: boolean;
+        message: () => string;
+    };
+    /**
+     * Assert that a member has a specific plan.
+     */
+    toHavePlan(received: Member | null, planId: string): {
+        pass: boolean;
+        message: () => string;
+    };
+    /**
+     * Assert that a member's email is verified.
+     */
+    toBeVerified(received: Member | null): {
+        pass: boolean;
+        message: () => "Expected member not to be verified" | "Expected member to be verified";
+    };
+};
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toBeLoggedIn(): R;
+            toHavePlan(planId: string): R;
+            toBeVerified(): R;
+        }
+    }
+}
+
+export { type MockMemberstackInstance, type MockMemberstackOptions, createMockMemberstack, memberstackMatchers, mockApp, mockCard, mockContentGroup, mockMember, mockPlan, mockPlanConnection, mockPrice };