@saasquatch/component-environment 1.0.0-1 → 1.0.0-4

package/dist/index.mjs

@@ -0,0 +1,386 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/types.ts
+var USER_CONTEXT_NAME = "sq:user-identity";
+var LOCALE_CONTEXT_NAME = "sq:locale";
+var PROGRAM_CONTEXT_NAME = "sq:program-id";
+var DEFAULT_MEDIUM = "EMBED";
+
+// src/environment.ts
+function getEnvironment() {
+  return getEnvironmentSDK().type;
+}
+function getEnvironmentSDK() {
+  var _a, _b;
+  if (window["SquatchAndroid"]) {
+    return {
+      type: "SquatchAndroid",
+      android: window["SquatchAndroid"],
+      widgetIdent: window["widgetIdent"]
+    };
+  }
+  if (window["SquatchPortal"]) {
+    return {
+      type: "SquatchPortal",
+      env: window["SquatchPortal"]
+    };
+  }
+  if (window["SquatchAdmin"]) {
+    return {
+      type: "SquatchAdmin",
+      adminSDK: window["SquatchAdmin"]
+    };
+  }
+  if (window["widgetIdent"] && ((_a = window["widgetIdent"]) == null ? void 0 : _a.env) !== "demo") {
+    return {
+      type: "SquatchJS2",
+      api: (_b = window.frameElement) == null ? void 0 : _b["squatchJsApi"],
+      widgetIdent: window["widgetIdent"]
+    };
+  }
+  return {
+    type: "None"
+  };
+}
+function isDemo() {
+  const sdk = getEnvironmentSDK();
+  return sdk.type === "None" || sdk.type === "SquatchAdmin";
+}
+var FAKE_TENANT = "demo";
+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;
+  }
+}
+var DEFAULT_DOMAIN = "https://app.referralsaasquatch.com";
+function getAppDomain() {
+  var _a;
+  const sdk = getEnvironmentSDK();
+  switch (sdk.type) {
+    case "SquatchAndroid":
+    case "SquatchJS2":
+      return sdk.widgetIdent.appDomain;
+    case "SquatchPortal":
+      return ((_a = sdk.env) == null ? void 0 : _a.appDomain) || DEFAULT_DOMAIN;
+    case "SquatchAdmin":
+    case "None":
+      return DEFAULT_DOMAIN;
+  }
+}
+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;
+  }
+}
+
+// src/contexts/UserIdentityContext.ts
+import decode from "jwt-decode";
+import { ContextProvider as ContextProvider2 } from "dom-context";
+import { equal } from "@wry/equality";
+
+// src/listeners.ts
+import { ContextListener } from "dom-context";
+
+// src/contexts/LocaleContext.ts
+import { ContextProvider } from "dom-context";
+
+// src/debug.ts
+var debugEnabled = localStorage.getItem("debug");
+function debug(ns, ...args) {
+  if (debugEnabled) {
+    console.debug(`sq:environment:${ns}`, ...args);
+  }
+}
+
+// src/contexts/LocaleContext.ts
+var debug2 = (...args) => debug(LOCALE_CONTEXT_NAME, ...args);
+function lazilyStartLocaleContext() {
+  var _a;
+  let globalProvider = window.squatchLocale;
+  if (!globalProvider) {
+    debug2("Creating locale context provider");
+    globalProvider = new ContextProvider({
+      element: document.documentElement,
+      initialState: ((_a = window.widgetIdent) == null ? void 0 : _a.locale) || navigator.language.replace("-", "_"),
+      contextName: LOCALE_CONTEXT_NAME
+    }).start();
+    window.squatchLocale = globalProvider;
+  }
+  return globalProvider;
+}
+function setLocale(locale) {
+  const globalProvider = lazilyStartLocaleContext();
+  if (globalProvider.context !== locale) {
+    debug2(`Setting locale context value [${locale}]`);
+    globalProvider.context = locale;
+  }
+}
+function getLocale() {
+  var _a;
+  return (_a = window.squatchLocale) == null ? void 0 : _a.context;
+}
+
+// src/fetchLocale.ts
+var debug3 = (...args) => debug(LOCALE_CONTEXT_NAME, ...args);
+var GET_LOCALE = `
+  query {
+    viewer {
+      ... on User {
+        locale
+      }
+    }
+  }
+`;
+async function fetchLocale() {
+  var _a;
+  debug3("Fetching locale from GraphQL for current user");
+  try {
+    const result = await fetch(`${getAppDomain()}/api/v1/${getTenantAlias()}/graphql`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${(_a = getUserIdentity()) == null ? void 0 : _a.jwt}`
+      },
+      body: JSON.stringify({
+        query: GET_LOCALE
+      })
+    });
+    if (!result.ok) {
+      throw new Error("Failed to fetch locale");
+    }
+    const json = await result.json();
+    if (json.errors) {
+      throw new Error(JSON.stringify(json.errors, null, 2));
+    }
+    return json.data.viewer.locale || void 0;
+  } catch (e) {
+    debug3(`Failed to fetch locale for current user`, e.message);
+    return void 0;
+  }
+}
+
+// src/listeners.ts
+var debug4 = (...args) => debug(LOCALE_CONTEXT_NAME, ...args);
+var userContextListenerDiv = (() => {
+  const id = "__environment_context_listener";
+  let div = document.getElementById(id);
+  if (!div) {
+    div = document.createElement("div");
+    div.id = id;
+    document.documentElement.appendChild(div);
+  }
+  return div;
+})();
+var userContextListenerForLocale = new ContextListener({
+  contextName: USER_CONTEXT_NAME,
+  element: userContextListenerDiv,
+  onChange: async (next) => {
+    var _a;
+    const localeProvider = lazilyStartLocaleContext();
+    const defaultLocale = ((_a = window.widgetIdent) == null ? void 0 : _a.locale) || navigator.language.replace("-", "_");
+    let newLocale;
+    if (next) {
+      debug4("User context changed, refetching locale");
+      const locale = await fetchLocale();
+      if (localeProvider.context !== locale) {
+        debug4(`New value fetched from GraphQL [${locale}]`);
+        newLocale = locale || defaultLocale;
+      }
+    } else {
+      newLocale = defaultLocale;
+    }
+    debug4(`Setting locale context to [${newLocale}]`);
+    localeProvider.context = newLocale;
+  }
+});
+function startUserContextListenerForLocale() {
+  debug4("Starting user context listener for locale updates");
+  userContextListenerForLocale.start();
+}
+
+// src/contexts/UserIdentityContext.ts
+var debug5 = (...args) => debug(USER_CONTEXT_NAME, ...args);
+function lazilyStartUserContext() {
+  let globalProvider = window.squatchUserIdentity;
+  if (!globalProvider) {
+    debug5("Creating user context provider");
+    globalProvider = new ContextProvider2({
+      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);
+}
+function userIdentityFromJwt(jwt) {
+  if (!jwt)
+    return void 0;
+  try {
+    const decoded = decode(jwt);
+    const exp = decoded.exp;
+    let userId = void 0;
+    let accountId = void 0;
+    if (isDecodedWidgetAPIJWT(decoded)) {
+      const matches = decoded.sub.match(/(.*):(.*)@(.*):users/);
+      if (matches == null ? void 0 : matches[1])
+        accountId = atob(matches[1]);
+      if (matches == null ? void 0 : matches[2])
+        userId = atob(matches[2]);
+    } else if (isDecodedSquatchJWT(decoded)) {
+      accountId = decoded.user.accountId;
+      userId = decoded.user.id;
+    }
+    if (!userId || !accountId) {
+      return void 0;
+    }
+    if (exp && Date.now() >= exp * 1e3) {
+      return void 0;
+    }
+    return {
+      id: userId,
+      accountId,
+      jwt
+    };
+  } catch (e) {
+    return void 0;
+  }
+}
+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":
+      const searchParams = new URLSearchParams(document.location.search);
+      if (searchParams.has("jwt")) {
+        return userIdentityFromJwt(searchParams.get("jwt"));
+      }
+      const stored = localStorage.getItem(USER_CONTEXT_NAME);
+      if (!stored)
+        return void 0;
+      try {
+        const potentialUserIdent = JSON.parse(stored);
+        const identity = userIdentityFromJwt(potentialUserIdent.jwt);
+        if (identity) {
+          return __spreadValues(__spreadValues({}, potentialUserIdent), identity);
+        }
+        return void 0;
+      } catch (e) {
+        return void 0;
+      }
+    case "SquatchAdmin":
+    case "None":
+      return void 0;
+  }
+}
+function setUserIdentity(identity) {
+  const globalProvider = lazilyStartUserContext();
+  if (!equal(globalProvider.context, identity)) {
+    debug5(`Setting user context value [${JSON.stringify(identity)}]`);
+    globalProvider.context = identity;
+  }
+  if (identity && getEnvironmentSDK().type === "SquatchPortal") {
+    localStorage.setItem(USER_CONTEXT_NAME, JSON.stringify(identity));
+  } else if (!identity) {
+    localStorage.removeItem(USER_CONTEXT_NAME);
+  }
+}
+function getUserIdentity() {
+  var _a;
+  return (_a = window.squatchUserIdentity) == null ? void 0 : _a.context;
+}
+
+// src/contexts/ProgramContext.ts
+import { ContextProvider as ContextProvider3 } from "dom-context";
+var debug6 = (...args) => debug(PROGRAM_CONTEXT_NAME, ...args);
+function lazilyStartProgramContext() {
+  var _a;
+  let globalProvider = window.squatchProgramId;
+  if (!globalProvider) {
+    debug6("Creating program context provider");
+    globalProvider = new ContextProvider3({
+      element: document.documentElement,
+      initialState: ((_a = window.widgetIdent) == null ? void 0 : _a.programId) || void 0,
+      contextName: PROGRAM_CONTEXT_NAME
+    }).start();
+    window.squatchProgramId = globalProvider;
+  }
+  return globalProvider;
+}
+function setProgramId(programId) {
+  const globalProvider = lazilyStartProgramContext();
+  if (globalProvider.context !== programId) {
+    debug6(`Setting program context value [${programId}]`);
+    globalProvider.context = programId;
+  }
+}
+function getProgramId() {
+  var _a;
+  return (_a = window.squatchLocale) == null ? void 0 : _a.context;
+}
+export {
+  DEFAULT_MEDIUM,
+  LOCALE_CONTEXT_NAME,
+  PROGRAM_CONTEXT_NAME,
+  USER_CONTEXT_NAME,
+  getAppDomain,
+  getEngagementMedium,
+  getEnvironment,
+  getEnvironmentSDK,
+  getLocale,
+  getProgramId,
+  getTenantAlias,
+  getUserIdentity,
+  isDemo,
+  lazilyStartLocaleContext,
+  lazilyStartProgramContext,
+  lazilyStartUserContext,
+  setLocale,
+  setProgramId,
+  setUserIdentity,
+  userIdentityFromJwt
+};

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@saasquatch/component-environment",
-  "version": "1.0.0-1",
+  "version": "1.0.0-4",
   "description": "Environment and contexts for SaaSquatch components",
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "files": [
+    "dist/"
+  ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsup src/index.ts --format esm,cjs --dts",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "engines": {
@@ -12,11 +16,13 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/saasquatch/program-tools.git"
+    "url": "https://github.com/saasquatch/program-tools",
+    "directory": "packages/component-environment"
   },
   "author": "Johan Venter <johan@saasquatch.com>",
   "license": "ISC",
   "devDependencies": {
+    "tsup": "^6.1.2",
     "typescript": "^4.7.3"
   },
   "dependencies": {

package/dist/LocaleContext.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,43 +0,0 @@
-// 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

@@ -1,13 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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;