@saasquatch/component-environment 1.0.0-0

package/dist/LocaleContext.d.ts

@@ -0,0 +1,7 @@
+export declare function lazilyStartLocaleContext(): void;
+/**
+ * Overide the globally defined Locale context
+ *
+ * @param locale the new locale used by the user
+ */
+export declare function setLocale(locale?: string): void;

package/dist/LocaleContext.js

@@ -0,0 +1,43 @@
+// const CONTEXT_NAME = "sq:locale";
+// const GET_LOCALE = gql`
+//   query {
+//     viewer {
+//       ... on User {
+//         locale
+//       }
+//     }
+//   }
+// `;
+export function lazilyStartLocaleContext() {
+    // const globalProvider = window.squatchLocale;
+    // const user = useUserIdentity();
+    // useEffect(() => {
+    //   // Clear locale if user is undefined
+    //   if (!user && globalProvider) {
+    //     return (globalProvider.context = undefined);
+    //   }
+    //   fetch({});
+    // }, [user]);
+    // const [fetch, { data }] = useLazyQuery(GET_LOCALE);
+    // const locale = data?.viewer?.locale;
+    // if (!globalProvider) {
+    //   // Lazily creates a global provider
+    //   window.squatchLocale = new ContextProvider<string>({
+    //     element: document.documentElement,
+    //     initialState: locale || window.widgetIdent?.locale || undefined,
+    //     contextName: CONTEXT_NAME,
+    //   }).start();
+    // } else if (locale !== globalProvider.context) {
+    //   globalProvider.context = locale;
+    // }
+}
+/**
+ * Overide the globally defined Locale context
+ *
+ * @param locale the new locale used by the user
+ */
+export function setLocale(locale) {
+    const globalProvider = window.squatchLocale;
+    if (globalProvider)
+        globalProvider.context = locale;
+}

package/dist/ProgramContext.d.ts

@@ -0,0 +1,13 @@
+import { ContextProvider } from "dom-context";
+/**
+ * Lazily start the program context provider
+ *
+ * @returns The global program context provider
+ */
+export declare function lazilyStartProgramContext(): ContextProvider<string | undefined>;
+/**
+ * Overide the globally defined Program ID context
+ *
+ * @param programId the new programID used by the user, or undefined if logged out
+ */
+export declare function setProgramId(programId: string | undefined): void;

package/dist/ProgramContext.js

@@ -0,0 +1,29 @@
+import { ContextProvider } from "dom-context";
+import { PROGRAM_CONTEXT_NAME } from "./types";
+/**
+ * Lazily start the program context provider
+ *
+ * @returns The global program context provider
+ */
+export function lazilyStartProgramContext() {
+    let globalProvider = window.squatchProgramId;
+    if (!globalProvider) {
+        // Lazily creates a global provider
+        globalProvider = new ContextProvider({
+            element: document.documentElement,
+            initialState: window.widgetIdent?.programId || undefined,
+            contextName: PROGRAM_CONTEXT_NAME,
+        }).start();
+        window.squatchProgramId = globalProvider;
+    }
+    return globalProvider;
+}
+/**
+ * Overide the globally defined Program ID context
+ *
+ * @param programId the new programID used by the user, or undefined if logged out
+ */
+export function setProgramId(programId) {
+    const globalProvider = lazilyStartProgramContext();
+    globalProvider.context = programId;
+}

package/dist/UserIdentityContext.d.ts

@@ -0,0 +1,10 @@
+import { ContextProvider } from "dom-context";
+import { UserIdentity } from "./types";
+export declare function lazilyStartUserContext(): ContextProvider<UserIdentity | undefined>;
+export declare function userIdentityFromJwt(jwt?: string): UserIdentity | undefined;
+/**
+ * Overide the globally defined user context, and persists the user identity in local storage
+ *
+ * @param identity the new identity of the user, or undefined if logged out
+ */
+export declare function setUserIdentity(identity?: UserIdentity): void;

package/dist/UserIdentityContext.js

@@ -0,0 +1,124 @@
+import decode from "jwt-decode";
+import { ContextProvider } from "dom-context";
+import { equal } from "@wry/equality";
+import { getEnvironmentSDK } from "./environment";
+import { setLocale } from "./LocaleContext";
+import { USER_CONTEXT_NAME, } from "./types";
+export function lazilyStartUserContext() {
+    let globalProvider = window.squatchUserIdentity;
+    if (!globalProvider) {
+        // Lazily creates a global provider
+        globalProvider = new ContextProvider({
+            element: document.documentElement,
+            initialState: _getInitialValue(),
+            contextName: USER_CONTEXT_NAME,
+        }).start();
+        window.squatchUserIdentity = globalProvider;
+    }
+    return globalProvider;
+}
+function isDecodedSquatchJWT(decoded) {
+    return decoded.user && decoded.user.id && decoded.user.accountId;
+}
+function isDecodedWidgetAPIJWT(decoded) {
+    return decoded.sub && /.*:.*@.*:users/.test(decoded.sub);
+}
+export function userIdentityFromJwt(jwt) {
+    if (!jwt)
+        return undefined;
+    try {
+        const decoded = decode(jwt);
+        const exp = decoded.exp;
+        let userId = undefined;
+        let accountId = undefined;
+        if (isDecodedWidgetAPIJWT(decoded)) {
+            // Pull the accountId and userId from the subject and Base64-decode them
+            // NOTE: This is to support classic theme engine widget token generation
+            const matches = decoded.sub.match(/(.*):(.*)@(.*):users/);
+            if (matches?.[1])
+                accountId = atob(matches[1]);
+            if (matches?.[2])
+                userId = atob(matches[2]);
+        }
+        else if (isDecodedSquatchJWT(decoded)) {
+            accountId = decoded.user.accountId;
+            userId = decoded.user.id;
+        }
+        if (!userId || !accountId) {
+            return undefined;
+        }
+        // Check if the JWT has expired
+        if (exp && Date.now() >= exp * 1000) {
+            return undefined;
+        }
+        return {
+            id: userId,
+            accountId: accountId,
+            jwt,
+        };
+    }
+    catch (e) {
+        // Invalid JWT
+        return undefined;
+    }
+}
+function _getInitialValue() {
+    const sdk = getEnvironmentSDK();
+    switch (sdk.type) {
+        case "SquatchAndroid":
+        case "SquatchJS2":
+            return {
+                id: sdk.widgetIdent.userId,
+                accountId: sdk.widgetIdent.accountId,
+                jwt: sdk.widgetIdent.token,
+            };
+        case "SquatchPortal":
+            // Portals can have the jwt provided as a URL parameter, so look for that first
+            const searchParams = new URLSearchParams(document.location.search);
+            if (searchParams.has("jwt")) {
+                return userIdentityFromJwt(searchParams.get("jwt"));
+            }
+            // Look for user identity in local storage
+            const stored = localStorage.getItem(USER_CONTEXT_NAME);
+            if (!stored)
+                return undefined;
+            try {
+                const potentialUserIdent = JSON.parse(stored);
+                const identity = userIdentityFromJwt(potentialUserIdent.jwt);
+                if (identity) {
+                    return {
+                        ...potentialUserIdent,
+                        ...identity,
+                    };
+                }
+                return undefined;
+            }
+            catch (e) {
+                // Not valid JSON
+                return undefined;
+            }
+        case "SquatchAdmin":
+        case "None":
+            // Not logged in for admin portal / none default case
+            return undefined;
+    }
+}
+/**
+ * Overide the globally defined user context, and persists the user identity in local storage
+ *
+ * @param identity the new identity of the user, or undefined if logged out
+ */
+export function setUserIdentity(identity) {
+    const globalProvider = lazilyStartUserContext();
+    if (!equal(globalProvider.context, identity)) {
+        setLocale(undefined);
+        globalProvider.context = identity;
+    }
+    // Portals store identity in local storage
+    if (identity && getEnvironmentSDK().type === "SquatchPortal") {
+        localStorage.setItem(USER_CONTEXT_NAME, JSON.stringify(identity));
+    }
+    else if (!identity) {
+        localStorage.removeItem(USER_CONTEXT_NAME);
+    }
+}

package/dist/contexts/LocaleContext.d.ts

@@ -0,0 +1,18 @@
+import { ContextProvider } from "dom-context";
+/**
+ * Lazily start the locale context provider. If it already exists, the existing provider is
+ * returned. This function is safe to call multiple times.
+ *
+ * @returns The global locale context provider
+ */
+export declare function lazilyStartLocaleContext(): ContextProvider<string | undefined>;
+/**
+ * Overide the globally defined Locale context
+ *
+ * @param locale the new locale used by the user
+ */
+export declare function setLocale(locale?: string): void;
+/**
+ * Get the current value of the locale context
+ */
+export declare function getLocale(): string | undefined;

package/dist/contexts/LocaleContext.js

@@ -0,0 +1,41 @@
+import { ContextProvider } from "dom-context";
+import { LOCALE_CONTEXT_NAME } from "../types";
+import { debug as _debug } from "../debug";
+const debug = (...args) => _debug(LOCALE_CONTEXT_NAME, ...args);
+/**
+ * Lazily start the locale context provider. If it already exists, the existing provider is
+ * returned. This function is safe to call multiple times.
+ *
+ * @returns The global locale context provider
+ */
+export function lazilyStartLocaleContext() {
+    let globalProvider = window.squatchLocale;
+    if (!globalProvider) {
+        debug("Creating locale context provider");
+        globalProvider = new ContextProvider({
+            element: document.documentElement,
+            initialState: window.widgetIdent?.locale || navigator.language.replace("-", "_"),
+            contextName: LOCALE_CONTEXT_NAME,
+        }).start();
+        window.squatchLocale = globalProvider;
+    }
+    return globalProvider;
+}
+/**
+ * Overide the globally defined Locale context
+ *
+ * @param locale the new locale used by the user
+ */
+export function setLocale(locale) {
+    const globalProvider = lazilyStartLocaleContext();
+    if (globalProvider.context !== locale) {
+        debug(`Setting locale context value [${locale}]`);
+        globalProvider.context = locale;
+    }
+}
+/**
+ * Get the current value of the locale context
+ */
+export function getLocale() {
+    return window.squatchLocale?.context;
+}

package/dist/contexts/ProgramContext.d.ts

@@ -0,0 +1,18 @@
+import { ContextProvider } from "dom-context";
+/**
+ * Lazily start the program context provider. If it already exists, the existing provider is
+ * returned. This function is safe to call multiple times.
+ *
+ * @returns The global program context provider
+ */
+export declare function lazilyStartProgramContext(): ContextProvider<string | undefined>;
+/**
+ * Overide the globally defined Program ID context
+ *
+ * @param programId the new programID used by the user, or undefined if logged out
+ */
+export declare function setProgramId(programId: string | undefined): void;
+/**
+ * Get the current value of the program context
+ */
+export declare function getProgramId(): string | undefined;

package/dist/contexts/ProgramContext.js

@@ -0,0 +1,42 @@
+import { ContextProvider } from "dom-context";
+import { PROGRAM_CONTEXT_NAME } from "../types";
+import { debug as _debug } from "../debug";
+const debug = (...args) => _debug(PROGRAM_CONTEXT_NAME, ...args);
+/**
+ * Lazily start the program context provider. If it already exists, the existing provider is
+ * returned. This function is safe to call multiple times.
+ *
+ * @returns The global program context provider
+ */
+export function lazilyStartProgramContext() {
+    let globalProvider = window.squatchProgramId;
+    if (!globalProvider) {
+        debug("Creating program context provider");
+        // Lazily creates a global provider
+        globalProvider = new ContextProvider({
+            element: document.documentElement,
+            initialState: window.widgetIdent?.programId || undefined,
+            contextName: PROGRAM_CONTEXT_NAME,
+        }).start();
+        window.squatchProgramId = globalProvider;
+    }
+    return globalProvider;
+}
+/**
+ * Overide the globally defined Program ID context
+ *
+ * @param programId the new programID used by the user, or undefined if logged out
+ */
+export function setProgramId(programId) {
+    const globalProvider = lazilyStartProgramContext();
+    if (globalProvider.context !== programId) {
+        debug(`Setting program context value [${programId}]`);
+        globalProvider.context = programId;
+    }
+}
+/**
+ * Get the current value of the program context
+ */
+export function getProgramId() {
+    return window.squatchLocale?.context;
+}

package/dist/contexts/UserIdentityContext.d.ts

@@ -0,0 +1,26 @@
+import { ContextProvider } from "dom-context";
+import { UserIdentity } from "../types";
+/**
+ * Lazily start the user context provider. If it already exists, the existing provider is
+ * returned. This function is safe to call multiple times.
+ *
+ * @returns The global user context provider
+ */
+export declare function lazilyStartUserContext(): ContextProvider<UserIdentity | undefined>;
+/**
+ * Extract a user identity from a JWT
+ *
+ * @param jwt The JWT to extract a user identity from
+ * @returns The user identity or undefined if the JWT is not valid
+ */
+export declare function userIdentityFromJwt(jwt?: string): UserIdentity | undefined;
+/**
+ * Overide the globally defined user context, and persists the user identity in local storage
+ *
+ * @param identity the new identity of the user, or undefined if logged out
+ */
+export declare function setUserIdentity(identity?: UserIdentity): void;
+/**
+ * Get the current value of the user context
+ */
+export declare function getUserIdentity(): UserIdentity | undefined;

package/dist/contexts/UserIdentityContext.js

@@ -0,0 +1,146 @@
+import decode from "jwt-decode";
+import { ContextProvider } from "dom-context";
+import { equal } from "@wry/equality";
+import { getEnvironmentSDK } from "../environment";
+import { USER_CONTEXT_NAME, } from "../types";
+import { startUserContextListenerForLocale } from "../listeners";
+import { debug as _debug } from "../debug";
+const debug = (...args) => _debug(USER_CONTEXT_NAME, ...args);
+/**
+ * Lazily start the user context provider. If it already exists, the existing provider is
+ * returned. This function is safe to call multiple times.
+ *
+ * @returns The global user context provider
+ */
+export function lazilyStartUserContext() {
+    let globalProvider = window.squatchUserIdentity;
+    if (!globalProvider) {
+        debug("Creating user context provider");
+        // Lazily creates a global provider
+        globalProvider = new ContextProvider({
+            element: document.documentElement,
+            initialState: _getInitialValue(),
+            contextName: USER_CONTEXT_NAME,
+        }).start();
+        window.squatchUserIdentity = globalProvider;
+        startUserContextListenerForLocale();
+    }
+    return globalProvider;
+}
+function isDecodedSquatchJWT(decoded) {
+    return decoded.user && decoded.user.id && decoded.user.accountId;
+}
+function isDecodedWidgetAPIJWT(decoded) {
+    return decoded.sub && /.*:.*@.*:users/.test(decoded.sub);
+}
+/**
+ * Extract a user identity from a JWT
+ *
+ * @param jwt The JWT to extract a user identity from
+ * @returns The user identity or undefined if the JWT is not valid
+ */
+export function userIdentityFromJwt(jwt) {
+    if (!jwt)
+        return undefined;
+    try {
+        const decoded = decode(jwt);
+        const exp = decoded.exp;
+        let userId = undefined;
+        let accountId = undefined;
+        if (isDecodedWidgetAPIJWT(decoded)) {
+            // Pull the accountId and userId from the subject and Base64-decode them
+            // NOTE: This is to support classic theme engine widget token generation
+            const matches = decoded.sub.match(/(.*):(.*)@(.*):users/);
+            if (matches?.[1])
+                accountId = atob(matches[1]);
+            if (matches?.[2])
+                userId = atob(matches[2]);
+        }
+        else if (isDecodedSquatchJWT(decoded)) {
+            accountId = decoded.user.accountId;
+            userId = decoded.user.id;
+        }
+        if (!userId || !accountId) {
+            return undefined;
+        }
+        // Check if the JWT has expired
+        if (exp && Date.now() >= exp * 1000) {
+            return undefined;
+        }
+        return {
+            id: userId,
+            accountId: accountId,
+            jwt,
+        };
+    }
+    catch (e) {
+        // Invalid JWT
+        return undefined;
+    }
+}
+function _getInitialValue() {
+    const sdk = getEnvironmentSDK();
+    switch (sdk.type) {
+        case "SquatchAndroid":
+        case "SquatchJS2":
+            return {
+                id: sdk.widgetIdent.userId,
+                accountId: sdk.widgetIdent.accountId,
+                jwt: sdk.widgetIdent.token,
+            };
+        case "SquatchPortal":
+            // Portals can have the jwt provided as a URL parameter, so look for that first
+            const searchParams = new URLSearchParams(document.location.search);
+            if (searchParams.has("jwt")) {
+                return userIdentityFromJwt(searchParams.get("jwt"));
+            }
+            // Look for user identity in local storage
+            const stored = localStorage.getItem(USER_CONTEXT_NAME);
+            if (!stored)
+                return undefined;
+            try {
+                const potentialUserIdent = JSON.parse(stored);
+                const identity = userIdentityFromJwt(potentialUserIdent.jwt);
+                if (identity) {
+                    return {
+                        ...potentialUserIdent,
+                        ...identity,
+                    };
+                }
+                return undefined;
+            }
+            catch (e) {
+                // Not valid JSON
+                return undefined;
+            }
+        case "SquatchAdmin":
+        case "None":
+            // Not logged in for admin portal / none default case
+            return undefined;
+    }
+}
+/**
+ * Overide the globally defined user context, and persists the user identity in local storage
+ *
+ * @param identity the new identity of the user, or undefined if logged out
+ */
+export function setUserIdentity(identity) {
+    const globalProvider = lazilyStartUserContext();
+    if (!equal(globalProvider.context, identity)) {
+        debug(`Setting user context value [${JSON.stringify(identity)}]`);
+        globalProvider.context = identity;
+    }
+    // Portals store identity in local storage
+    if (identity && getEnvironmentSDK().type === "SquatchPortal") {
+        localStorage.setItem(USER_CONTEXT_NAME, JSON.stringify(identity));
+    }
+    else if (!identity) {
+        localStorage.removeItem(USER_CONTEXT_NAME);
+    }
+}
+/**
+ * Get the current value of the user context
+ */
+export function getUserIdentity() {
+    return window.squatchUserIdentity?.context;
+}

package/dist/debug.d.ts

@@ -0,0 +1 @@
+export declare function debug(ns: string, ...args: any[]): void;

package/dist/debug.js

@@ -0,0 +1,6 @@
+const debugEnabled = localStorage.getItem("debug");
+export function debug(ns, ...args) {
+    if (debugEnabled) {
+        console.debug(`sq:environment:${ns}`, ...args);
+    }
+}

package/dist/environment.d.ts

@@ -0,0 +1,15 @@
+import { Environment, EnvironmentSDK, EngagementMedium } from "./types";
+/**
+ * Get the type of environment that this widget is being rendered in
+ *
+ * Should never return null.
+ */
+export declare function getEnvironment(): Environment;
+/**
+ * Get the SDK for interacting with the host environment
+ */
+export declare function getEnvironmentSDK(): EnvironmentSDK;
+export declare function isDemo(): boolean;
+export declare function getTenantAlias(): string;
+export declare function getAppDomain(): string;
+export declare function getEngagementMedium(): EngagementMedium;

package/dist/environment.js

@@ -0,0 +1,98 @@
+import { DEFAULT_MEDIUM, } from "./types";
+/**
+ * Get the type of environment that this widget is being rendered in
+ *
+ * Should never return null.
+ */
+export function getEnvironment() {
+    return getEnvironmentSDK().type;
+}
+/**
+ * Get the SDK for interacting with the host environment
+ */
+export function getEnvironmentSDK() {
+    //@ts-ignore
+    if (window["SquatchAndroid"]) {
+        return {
+            type: "SquatchAndroid",
+            //@ts-ignore
+            android: window["SquatchAndroid"],
+            //@ts-ignore
+            widgetIdent: window["widgetIdent"],
+        };
+    }
+    //@ts-ignore
+    if (window["SquatchPortal"]) {
+        return {
+            type: "SquatchPortal",
+            //@ts-ignore
+            env: window["SquatchPortal"],
+        };
+    }
+    //@ts-ignore
+    if (window["SquatchAdmin"]) {
+        return {
+            type: "SquatchAdmin",
+            //@ts-ignore
+            adminSDK: window["SquatchAdmin"],
+        };
+    }
+    // Vanilla components mutates `widgetIdent` for portal, causing boilerplate to render as SquatchJS2
+    if (window["widgetIdent"] && window["widgetIdent"]?.env !== "demo") {
+        return {
+            type: "SquatchJS2",
+            //@ts-ignore
+            api: window.frameElement?.["squatchJsApi"],
+            //@ts-ignore
+            widgetIdent: window["widgetIdent"],
+        };
+    }
+    return {
+        type: "None",
+    };
+}
+export function isDemo() {
+    const sdk = getEnvironmentSDK();
+    return sdk.type === "None" || sdk.type === "SquatchAdmin";
+}
+// Fake tenant alias in demo mode
+const FAKE_TENANT = "demo";
+export function getTenantAlias() {
+    const sdk = getEnvironmentSDK();
+    switch (sdk.type) {
+        case "SquatchAndroid":
+        case "SquatchJS2":
+            return sdk.widgetIdent.tenantAlias;
+        case "SquatchAdmin":
+        case "None":
+            return FAKE_TENANT;
+        case "SquatchPortal":
+            return sdk.env.tenantAlias;
+    }
+}
+const DEFAULT_DOMAIN = "https://app.referralsaasquatch.com";
+export function getAppDomain() {
+    const sdk = getEnvironmentSDK();
+    switch (sdk.type) {
+        case "SquatchAndroid":
+        case "SquatchJS2":
+            return sdk.widgetIdent.appDomain;
+        case "SquatchPortal":
+            return sdk.env?.appDomain || DEFAULT_DOMAIN;
+        case "SquatchAdmin":
+        case "None":
+            return DEFAULT_DOMAIN;
+    }
+}
+export function getEngagementMedium() {
+    const sdk = getEnvironmentSDK();
+    switch (sdk.type) {
+        case "SquatchJS2":
+            return sdk.widgetIdent.engagementMedium || DEFAULT_MEDIUM;
+        case "SquatchAndroid":
+        case "SquatchPortal":
+        case "SquatchAdmin":
+        case "None":
+            return DEFAULT_MEDIUM;
+    }
+}

package/dist/fetchLocale.d.ts

@@ -0,0 +1 @@
+export declare function fetchLocale(): Promise<string | undefined>;