@themodcraft/addon-packs 1.1.0

package/README.md

@@ -0,0 +1,13 @@
+# `@themodcraft/addon-packs`
+
+Bundle package that re-exports the addon family.
+
+Use this when you want the full set of addon packages instead of installing them individually.
+
+Install:
+```bash
+npm install @themodcraft/addon-packs
+```
+
+This package publishes compiled output only.
+

package/dist/addons/animations/animated-number/AnimatedNumber.d.ts

@@ -0,0 +1,2 @@
+import type { AnimatedNumberProps } from "./AnimatedNumber.types";
+export declare function AnimatedNumber({ className, durationMs, format, value, }: AnimatedNumberProps): import("react").JSX.Element;

package/dist/addons/animations/animated-number/AnimatedNumber.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+export function AnimatedNumber({ className, durationMs = 800, format = (value) => String(Math.round(value)), value, }) {
+    const [displayValue, setDisplayValue] = useState(value);
+    const displayValueRef = useRef(value);
+    useEffect(() => {
+        displayValueRef.current = displayValue;
+    }, [displayValue]);
+    useEffect(() => {
+        const start = performance.now();
+        const from = displayValueRef.current;
+        const delta = value - from;
+        let frame = 0;
+        function tick(now) {
+            const progress = Math.min((now - start) / durationMs, 1);
+            const eased = 1 - Math.pow(1 - progress, 3);
+            const nextValue = from + delta * eased;
+            displayValueRef.current = nextValue;
+            setDisplayValue(nextValue);
+            if (progress < 1) {
+                frame = requestAnimationFrame(tick);
+            }
+        }
+        frame = requestAnimationFrame(tick);
+        return () => cancelAnimationFrame(frame);
+    }, [durationMs, value]);
+    return _jsx("span", { className: className, children: format(displayValue) });
+}

package/dist/addons/animations/animated-number/AnimatedNumber.types.d.ts

@@ -0,0 +1,6 @@
+export interface AnimatedNumberProps {
+    className?: string;
+    durationMs?: number;
+    format?: (value: number) => string;
+    value: number;
+}

package/dist/addons/animations/animated-number/AnimatedNumber.types.js

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

package/dist/addons/animations/animated-number/index.d.ts

@@ -0,0 +1,2 @@
+export { AnimatedNumber } from "./AnimatedNumber";
+export type { AnimatedNumberProps } from "./AnimatedNumber.types";

package/dist/addons/animations/animated-number/index.js

@@ -0,0 +1 @@
+export { AnimatedNumber } from "./AnimatedNumber";

package/dist/addons/animations/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-animations";

package/dist/addons/animations/index.js

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-animations";

package/dist/addons/artstyles/colors/color-utils.d.ts

@@ -0,0 +1,23 @@
+export interface RgbColor {
+    a?: number;
+    b: number;
+    g: number;
+    r: number;
+}
+export interface HslColor {
+    a?: number;
+    h: number;
+    l: number;
+    s: number;
+}
+export type ColorInput = HslColor | RgbColor | string;
+export type TransformColorMode = "contrast" | "grayscale" | "invert";
+export declare function isValidHex(hex: string): boolean;
+export declare function rgbToHex(rgb: string): string | null;
+export declare function rgbaToHex({ a, b, g, r }: RgbColor): string;
+export declare function hexToRgb(hex: string): RgbColor | null;
+export declare function convertToHex(color: ColorInput): string | null;
+export declare function shiftColorLightness(hex: string, amount: number): string;
+export declare function darken(hex: string, amount: number): string;
+export declare function lighten(hex: string, amount: number): string;
+export declare function transformColor(hex: string, mode: TransformColorMode): string;

package/dist/addons/artstyles/colors/color-utils.js

@@ -0,0 +1,141 @@
+function clampChannel(value) {
+    return Math.max(0, Math.min(255, Math.round(value)));
+}
+function clampAlpha(value) {
+    return Math.max(0, Math.min(1, value));
+}
+function toHexChannel(value) {
+    return clampChannel(value).toString(16).padStart(2, "0").toUpperCase();
+}
+function normalizeHex(hex) {
+    const value = hex.trim();
+    if (/^#([0-9A-Fa-f]{3})$/.test(value)) {
+        const [, shortHex] = value.match(/^#([0-9A-Fa-f]{3})$/) ?? [];
+        return `#${shortHex.split("").map((channel) => `${channel}${channel}`).join("")}`.toUpperCase();
+    }
+    if (/^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/.test(value)) {
+        return value.toUpperCase();
+    }
+    return null;
+}
+function hslToRgb({ h, l, s }) {
+    const hue = ((h % 360) + 360) % 360;
+    const saturation = Math.max(0, Math.min(100, s)) / 100;
+    const lightness = Math.max(0, Math.min(100, l)) / 100;
+    const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+    const x = chroma * (1 - Math.abs(((hue / 60) % 2) - 1));
+    const m = lightness - chroma / 2;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    if (hue < 60) {
+        r = chroma;
+        g = x;
+    }
+    else if (hue < 120) {
+        r = x;
+        g = chroma;
+    }
+    else if (hue < 180) {
+        g = chroma;
+        b = x;
+    }
+    else if (hue < 240) {
+        g = x;
+        b = chroma;
+    }
+    else if (hue < 300) {
+        r = x;
+        b = chroma;
+    }
+    else {
+        r = chroma;
+        b = x;
+    }
+    return {
+        b: clampChannel((b + m) * 255),
+        g: clampChannel((g + m) * 255),
+        r: clampChannel((r + m) * 255),
+    };
+}
+export function isValidHex(hex) {
+    return Boolean(normalizeHex(hex));
+}
+export function rgbToHex(rgb) {
+    const channels = rgb.match(/-?\d+(\.\d+)?/g)?.map(Number);
+    if (!channels || channels.length < 3) {
+        return null;
+    }
+    const [r, g, b] = channels;
+    return `#${toHexChannel(r)}${toHexChannel(g)}${toHexChannel(b)}`;
+}
+export function rgbaToHex({ a, b, g, r }) {
+    const alpha = typeof a === "number" ? toHexChannel(clampAlpha(a) * 255) : "";
+    return `#${toHexChannel(r)}${toHexChannel(g)}${toHexChannel(b)}${alpha}`;
+}
+export function hexToRgb(hex) {
+    const normalized = normalizeHex(hex);
+    if (!normalized) {
+        return null;
+    }
+    return {
+        b: parseInt(normalized.slice(5, 7), 16),
+        g: parseInt(normalized.slice(3, 5), 16),
+        r: parseInt(normalized.slice(1, 3), 16),
+    };
+}
+export function convertToHex(color) {
+    if (typeof color === "string") {
+        const normalizedHex = normalizeHex(color);
+        if (normalizedHex) {
+            return normalizedHex;
+        }
+        return rgbToHex(color);
+    }
+    if ("r" in color) {
+        return rgbaToHex(color);
+    }
+    const rgb = hslToRgb(color);
+    const alpha = typeof color.a === "number" ? toHexChannel(clampAlpha(color.a) * 255) : "";
+    return `${rgbaToHex(rgb)}${alpha}`;
+}
+export function shiftColorLightness(hex, amount) {
+    const rgb = hexToRgb(hex);
+    if (!rgb) {
+        return "#000000";
+    }
+    return rgbaToHex({
+        b: rgb.b + amount,
+        g: rgb.g + amount,
+        r: rgb.r + amount,
+    });
+}
+export function darken(hex, amount) {
+    return shiftColorLightness(hex, -Math.abs(amount));
+}
+export function lighten(hex, amount) {
+    return shiftColorLightness(hex, Math.abs(amount));
+}
+export function transformColor(hex, mode) {
+    const rgb = hexToRgb(hex);
+    if (!rgb) {
+        return "#000000";
+    }
+    if (mode === "contrast") {
+        const yiq = (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
+        return yiq >= 128 ? "#000000" : "#FFFFFF";
+    }
+    if (mode === "invert") {
+        return rgbaToHex({
+            b: 255 - rgb.b,
+            g: 255 - rgb.g,
+            r: 255 - rgb.r,
+        });
+    }
+    const luma = 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b;
+    return rgbaToHex({
+        b: luma,
+        g: luma,
+        r: luma,
+    });
+}

package/dist/addons/artstyles/colors/index.d.ts

@@ -0,0 +1 @@
+export { convertToHex, darken, hexToRgb, isValidHex, lighten, rgbaToHex, rgbToHex, shiftColorLightness, transformColor, type ColorInput, type HslColor, type RgbColor, type TransformColorMode, } from "./color-utils";

package/dist/addons/artstyles/colors/index.js

@@ -0,0 +1 @@
+export { convertToHex, darken, hexToRgb, isValidHex, lighten, rgbaToHex, rgbToHex, shiftColorLightness, transformColor, } from "./color-utils";

package/dist/addons/artstyles/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-artstyles";

package/dist/addons/artstyles/index.js

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-artstyles";

package/dist/addons/charts/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-charts";

package/dist/addons/charts/index.js

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-charts";

package/dist/addons/charts/mini-bar-chart/MiniBarChart.d.ts

@@ -0,0 +1,2 @@
+import type { MiniBarChartProps } from "./MiniBarChart.types";
+export declare function MiniBarChart({ ariaLabel, chartOptions, className, data, height, maxValue, showXAxis, showYAxis, }: MiniBarChartProps): import("react").JSX.Element;

package/dist/addons/charts/mini-bar-chart/MiniBarChart.js

@@ -0,0 +1,72 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BarElement, CategoryScale, Chart as ChartJS, LinearScale, Tooltip, } from "chart.js";
+import { useMemo } from "react";
+import { Bar } from "react-chartjs-2";
+ChartJS.register(CategoryScale, LinearScale, BarElement, Tooltip);
+function mergeChartOptions(baseOptions, chartOptions) {
+    return {
+        ...baseOptions,
+        ...chartOptions,
+        plugins: {
+            ...baseOptions.plugins,
+            ...chartOptions?.plugins,
+        },
+        scales: {
+            ...baseOptions.scales,
+            ...chartOptions?.scales,
+        },
+    };
+}
+export function MiniBarChart({ ariaLabel = "Mini bar chart", chartOptions, className, data, height, maxValue, showXAxis = false, showYAxis = true, }) {
+    const chartMax = maxValue ?? Math.max(...data.map((item) => item.value), 1);
+    const resolvedHeight = height ?? Math.max(data.length * 42, 120);
+    const chartData = useMemo(() => ({
+        labels: data.map((item) => item.label),
+        datasets: [
+            {
+                backgroundColor: data.map((item) => item.color ?? "#0b63ce"),
+                borderRadius: 6,
+                borderSkipped: false,
+                data: data.map((item) => item.value),
+                label: ariaLabel,
+            },
+        ],
+    }), [ariaLabel, data]);
+    const options = useMemo(() => mergeChartOptions({
+        animation: {
+            duration: 220,
+        },
+        indexAxis: "y",
+        maintainAspectRatio: false,
+        plugins: {
+            legend: {
+                display: false,
+            },
+            tooltip: {
+                enabled: true,
+            },
+        },
+        responsive: true,
+        scales: {
+            x: {
+                beginAtZero: true,
+                display: showXAxis,
+                grid: {
+                    display: showXAxis,
+                },
+                max: chartMax,
+                ticks: {
+                    precision: 0,
+                },
+            },
+            y: {
+                display: showYAxis,
+                grid: {
+                    display: false,
+                },
+            },
+        },
+    }, chartOptions), [chartMax, chartOptions, showXAxis, showYAxis]);
+    return (_jsx("div", { "aria-label": ariaLabel, className: className, role: "img", style: { height: resolvedHeight }, children: _jsx(Bar, { data: chartData, options: options }) }));
+}

package/dist/addons/charts/mini-bar-chart/MiniBarChart.types.d.ts

@@ -0,0 +1,16 @@
+import type { ChartOptions } from "chart.js";
+export interface MiniBarChartDatum {
+    color?: string;
+    label: string;
+    value: number;
+}
+export interface MiniBarChartProps {
+    ariaLabel?: string;
+    chartOptions?: ChartOptions<"bar">;
+    className?: string;
+    data: MiniBarChartDatum[];
+    height?: number | string;
+    maxValue?: number;
+    showXAxis?: boolean;
+    showYAxis?: boolean;
+}

package/dist/addons/charts/mini-bar-chart/MiniBarChart.types.js

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

package/dist/addons/charts/mini-bar-chart/index.d.ts

@@ -0,0 +1,2 @@
+export { MiniBarChart } from "./MiniBarChart";
+export type { MiniBarChartDatum, MiniBarChartProps } from "./MiniBarChart.types";

package/dist/addons/charts/mini-bar-chart/index.js

@@ -0,0 +1 @@
+export { MiniBarChart } from "./MiniBarChart";

package/dist/addons/configs/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-configs";

package/dist/addons/configs/index.js

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-configs";

package/dist/addons/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./artstyles";
+export * from "./animations";
+export * from "./charts";
+export * from "./configs";
+export * from "./integrations";
+export * from "./paywall";
+export * from "./providers";
+export * from "./themes";

package/dist/addons/index.js

@@ -0,0 +1,8 @@
+export * from "./artstyles";
+export * from "./animations";
+export * from "./charts";
+export * from "./configs";
+export * from "./integrations";
+export * from "./paywall";
+export * from "./providers";
+export * from "./themes";

package/dist/addons/integrations/better-auth/better-auth.d.ts

@@ -0,0 +1,16 @@
+export interface BetterAuthUserLike {
+    email?: string | null;
+    image?: string | null;
+    name?: string | null;
+    username?: string | null;
+}
+export interface BetterAuthSessionLike {
+    user?: BetterAuthUserLike | null;
+}
+export interface BetterAuthNavbarProfile {
+    email?: string | null;
+    image?: string | null;
+    name?: string | null;
+    username?: string | null;
+}
+export declare function profileFromBetterAuthSession(session: BetterAuthSessionLike | null | undefined): BetterAuthNavbarProfile | null;

package/dist/addons/integrations/better-auth/better-auth.js

@@ -0,0 +1,11 @@
+export function profileFromBetterAuthSession(session) {
+    if (!session?.user) {
+        return null;
+    }
+    return {
+        email: session.user.email ?? null,
+        image: session.user.image ?? null,
+        name: session.user.name ?? null,
+        username: session.user.username ?? null,
+    };
+}

package/dist/addons/integrations/better-auth/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-integrations/better-auth";

package/dist/addons/integrations/better-auth/index.js

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-integrations/better-auth";

package/dist/addons/integrations/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-integrations";

package/dist/addons/integrations/index.js

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-integrations";

package/dist/addons/paywall/Paywall.d.ts

@@ -0,0 +1,5 @@
+import type { PaywallContextValue, PaywallGateProps, PaywallProviderProps } from "./Paywall.types";
+export declare function PaywallProvider({ checkoutUrl, children, defaultFallback, entitlements, onCheckout, plans, resolveEntitlements, status, }: PaywallProviderProps): import("react").JSX.Element;
+export declare function usePaywall(): PaywallContextValue;
+export declare function useOptionalPaywall(): PaywallContextValue | null;
+export declare function PaywallGate({ children, fallback, loadingFallback, mode, planId, required, }: PaywallGateProps): string | number | bigint | boolean | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | null | undefined;

package/dist/addons/paywall/Paywall.js

@@ -0,0 +1,145 @@
+"use client";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { createContext, isValidElement, useCallback, useContext, useEffect, useMemo, useState, } from "react";
+const PaywallContext = createContext(null);
+function normalizeEntitlements(requiredEntitlements) {
+    if (!requiredEntitlements) {
+        return [];
+    }
+    return Array.isArray(requiredEntitlements)
+        ? requiredEntitlements.filter(Boolean)
+        : [requiredEntitlements].filter(Boolean);
+}
+function checkEntitlements(entitlements, requiredEntitlements, mode = "all") {
+    const required = normalizeEntitlements(requiredEntitlements);
+    if (!required.length) {
+        return true;
+    }
+    if (mode === "any") {
+        return required.some((entitlement) => entitlements.includes(entitlement));
+    }
+    return required.every((entitlement) => entitlements.includes(entitlement));
+}
+function missingEntitlements(entitlements, requiredEntitlements, mode = "all") {
+    const required = normalizeEntitlements(requiredEntitlements);
+    if (mode === "any" && required.some((entitlement) => entitlements.includes(entitlement))) {
+        return [];
+    }
+    return required.filter((entitlement) => !entitlements.includes(entitlement));
+}
+function renderFallback(fallback, decision, actions) {
+    if (typeof fallback === "function" && !isValidElement(fallback)) {
+        return fallback(decision, actions);
+    }
+    return fallback;
+}
+function DefaultPaywallFallback({ decision, startCheckout, }) {
+    const planLabel = decision.plan?.label ?? "Pro";
+    return (_jsxs("div", { role: "group", style: { border: "1px solid var(--tmc-color-border, #d7dde5)", borderRadius: "8px", padding: "16px" }, children: [_jsxs("p", { style: { color: "var(--tmc-color-text, #111827)", fontWeight: 600, margin: 0 }, children: [planLabel, " access required"] }), _jsx("p", { style: { color: "var(--tmc-color-text-muted, #5f6b7a)", margin: "8px 0 0" }, children: "This package area is locked until the required entitlement is active." }), _jsx("button", { onClick: () => void startCheckout(), style: { background: "var(--tmc-color-accent, #0b63ce)", border: 0, borderRadius: "6px", color: "var(--tmc-color-accent-text, #ffffff)", cursor: "pointer", marginTop: "12px", padding: "8px 12px" }, type: "button", children: "Unlock" })] }));
+}
+export function PaywallProvider({ checkoutUrl, children, defaultFallback, entitlements = [], onCheckout, plans = [], resolveEntitlements, status = "ready", }) {
+    const [resolvedEntitlements, setResolvedEntitlements] = useState(entitlements);
+    const [resolvedStatus, setResolvedStatus] = useState(status);
+    useEffect(() => {
+        setResolvedEntitlements(entitlements);
+        setResolvedStatus(status);
+    }, [entitlements, status]);
+    const refreshEntitlements = useCallback(async () => {
+        if (!resolveEntitlements) {
+            return resolvedEntitlements;
+        }
+        setResolvedStatus("loading");
+        try {
+            const nextEntitlements = await resolveEntitlements();
+            setResolvedEntitlements(nextEntitlements);
+            setResolvedStatus("ready");
+            return nextEntitlements;
+        }
+        catch {
+            setResolvedStatus("error");
+            return [];
+        }
+    }, [resolveEntitlements, resolvedEntitlements]);
+    useEffect(() => {
+        if (!resolveEntitlements) {
+            return;
+        }
+        void refreshEntitlements();
+    }, [refreshEntitlements, resolveEntitlements]);
+    const getDecision = useCallback((requiredEntitlements, mode = "all", planId) => {
+        const required = normalizeEntitlements(requiredEntitlements);
+        const plan = plans.find((currentPlan) => currentPlan.id === planId) ?? plans.find((currentPlan) => currentPlan.entitlements?.some((entitlement) => required.includes(entitlement)));
+        const allowed = resolvedStatus === "ready" && checkEntitlements(resolvedEntitlements, required, mode);
+        return {
+            allowed,
+            missingEntitlements: missingEntitlements(resolvedEntitlements, required, mode),
+            plan,
+            requiredEntitlements: required,
+            status: resolvedStatus,
+        };
+    }, [plans, resolvedEntitlements, resolvedStatus]);
+    const hasEntitlements = useCallback((requiredEntitlements, mode = "all") => (getDecision(requiredEntitlements, mode).allowed), [getDecision]);
+    const startCheckout = useCallback(async (planId, decision) => {
+        const plan = plans.find((currentPlan) => currentPlan.id === planId) ?? decision?.plan;
+        const nextDecision = decision ?? getDecision(plan?.entitlements, "all", plan?.id);
+        if (onCheckout) {
+            await onCheckout(plan, nextDecision);
+            return;
+        }
+        const url = plan?.checkoutUrl ?? checkoutUrl;
+        if (url && typeof window !== "undefined") {
+            window.location.href = url;
+        }
+    }, [checkoutUrl, getDecision, onCheckout, plans]);
+    const value = useMemo(() => ({
+        checkoutUrl,
+        defaultFallback,
+        entitlements: resolvedEntitlements,
+        getDecision,
+        hasEntitlements,
+        plans,
+        refreshEntitlements,
+        startCheckout,
+        status: resolvedStatus,
+    }), [
+        checkoutUrl,
+        defaultFallback,
+        getDecision,
+        hasEntitlements,
+        plans,
+        refreshEntitlements,
+        resolvedEntitlements,
+        resolvedStatus,
+        startCheckout,
+    ]);
+    return _jsx(PaywallContext.Provider, { value: value, children: children });
+}
+export function usePaywall() {
+    const context = useContext(PaywallContext);
+    if (!context) {
+        throw new Error("usePaywall must be used inside PaywallProvider.");
+    }
+    return context;
+}
+export function useOptionalPaywall() {
+    return useContext(PaywallContext);
+}
+export function PaywallGate({ children, fallback, loadingFallback = null, mode = "all", planId, required, }) {
+    const paywall = usePaywall();
+    const decision = paywall.getDecision(required, mode, planId);
+    const actions = {
+        refreshEntitlements: paywall.refreshEntitlements,
+        startCheckout: () => paywall.startCheckout(planId, decision),
+    };
+    if (decision.status === "loading") {
+        return loadingFallback;
+    }
+    if (decision.allowed) {
+        return children;
+    }
+    const renderedFallback = renderFallback(fallback ?? paywall.defaultFallback, decision, actions);
+    if (renderedFallback) {
+        return renderedFallback;
+    }
+    return _jsx(DefaultPaywallFallback, { decision: decision, startCheckout: actions.startCheckout });
+}

package/dist/addons/paywall/Paywall.types.d.ts

@@ -0,0 +1,54 @@
+import type { ReactNode } from "react";
+export type PaywallAccessMode = "all" | "any";
+export type PaywallStatus = "error" | "loading" | "ready";
+export interface PaywallPlan {
+    checkoutUrl?: string;
+    entitlements?: string[];
+    id: string;
+    label: string;
+    priceLabel?: string;
+}
+export interface PaywallDecision {
+    allowed: boolean;
+    missingEntitlements: string[];
+    plan?: PaywallPlan;
+    requiredEntitlements: string[];
+    status: PaywallStatus;
+}
+export interface PaywallActions {
+    refreshEntitlements: () => Promise<string[]>;
+    startCheckout: (planId?: string) => Promise<void>;
+}
+export type PaywallFallbackRenderer = (decision: PaywallDecision, actions: PaywallActions) => ReactNode;
+export type PaywallFallback = ReactNode | PaywallFallbackRenderer;
+export type EntitlementResolver = () => Promise<string[]> | string[];
+export type PaywallCheckoutHandler = (plan: PaywallPlan | undefined, decision: PaywallDecision) => Promise<void> | void;
+export interface PaywallProviderProps {
+    checkoutUrl?: string;
+    children: ReactNode;
+    defaultFallback?: PaywallFallback;
+    entitlements?: string[];
+    onCheckout?: PaywallCheckoutHandler;
+    plans?: PaywallPlan[];
+    resolveEntitlements?: EntitlementResolver;
+    status?: PaywallStatus;
+}
+export interface PaywallContextValue {
+    checkoutUrl?: string;
+    defaultFallback?: PaywallFallback;
+    entitlements: string[];
+    getDecision: (requiredEntitlements?: string | string[], mode?: PaywallAccessMode, planId?: string) => PaywallDecision;
+    hasEntitlements: (requiredEntitlements?: string | string[], mode?: PaywallAccessMode) => boolean;
+    plans: PaywallPlan[];
+    refreshEntitlements: () => Promise<string[]>;
+    startCheckout: (planId?: string, decision?: PaywallDecision) => Promise<void>;
+    status: PaywallStatus;
+}
+export interface PaywallGateProps {
+    children: ReactNode;
+    fallback?: PaywallFallback;
+    loadingFallback?: ReactNode;
+    mode?: PaywallAccessMode;
+    planId?: string;
+    required?: string | string[];
+}

package/dist/addons/paywall/Paywall.types.js

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

package/dist/addons/paywall/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-paywall";

package/dist/addons/paywall/index.js

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-paywall";

package/dist/addons/providers/auth/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-providers/auth";

package/dist/addons/providers/auth/index.js

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-providers/auth";

package/dist/addons/providers/index.d.ts

@@ -0,0 +1 @@
+export * from "@themodcraft/addon-providers";