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

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2022-06-16
+
+Initial version.
+
+[unreleased]: https://github.com/saasquatch/program-tools/compare/component-environment@1.0.0...HEAD
+[1.0.0]: https://github.com/saasquatch/program-tools/releases/tag/%40saasquatch%2Fcomponent-environment%401.0.0

package/README.md

@@ -0,0 +1 @@
+Provides the environment for running SaaSquatch web components.

package/dist/index.d.ts

@@ -1,5 +1,226 @@
-export * from "./types";
-export * from "./environment";
-export * from "./contexts/UserIdentityContext";
-export * from "./contexts/LocaleContext";
-export * from "./contexts/ProgramContext";
+import { ContextProvider } from 'dom-context';
+
+declare global {
+    interface Window {
+        SquatchPortal?: PortalEnv;
+        widgetIdent?: WidgetIdent;
+        squatchUserIdentity?: ContextProvider<UserIdentity | undefined>;
+        squatchLocale?: ContextProvider<string | undefined>;
+        squatchProgramId?: ContextProvider<string | undefined>;
+    }
+}
+declare type UserContextName = "sq:user-identity";
+declare type LocaleContextName = "sq:locale";
+declare type ProgramContextName = "sq:program-id";
+declare const USER_CONTEXT_NAME: UserContextName;
+declare const LOCALE_CONTEXT_NAME: LocaleContextName;
+declare const PROGRAM_CONTEXT_NAME: ProgramContextName;
+/**
+ * The value stored in the UserContext
+ */
+declare type UserIdentity = {
+    id: string;
+    accountId: string;
+    jwt?: string;
+    managedIdentity?: {
+        email: string;
+        emailVerified: boolean;
+        sessionData?: {
+            [key: string]: any;
+        };
+    };
+};
+declare type UserId = {
+    id: string;
+    accountId: string;
+};
+interface DecodedSquatchJWT {
+    exp?: number;
+    user: {
+        accountId: string;
+        id: string;
+    };
+}
+interface DecodedWidgetAPIJWT {
+    exp?: number;
+    sub: string;
+}
+declare type EngagementMedium = "EMBED" | "POPUP";
+declare const DEFAULT_MEDIUM: EngagementMedium;
+/**
+ * Provided by the SaaSquatch GraphQL backend when a widget is rendered.
+ *
+ * Source: https://github.com/saasquatch/saasquatch/blob/805e51284f818f8656b6458bcee6181f378819d3/packages/saasquatch-core/app/saasquatch/controllers/api/widget/WidgetApi.java
+ *
+ */
+interface WidgetIdent {
+    tenantAlias: string;
+    appDomain: string;
+    token: string;
+    userId: string;
+    accountId: string;
+    locale?: string;
+    engagementMedium?: "POPUP" | "EMBED";
+    programId?: string;
+    env?: string;
+}
+/**
+ * Portal env doesn't include User Id
+ */
+declare type PortalEnv = Pick<WidgetIdent, "tenantAlias" | "appDomain" | "programId">;
+/**
+ * An interface for interacting with the SaaSquatch Admin Portal.
+ *
+ * Used for rendering widgets in a preview/demo mode.
+ */
+interface SquatchAdmin {
+    /**
+     * Provides a way of providing user feedback when a widget is rendered in the SaaSquatch admin portal
+     *
+     * @param text
+     */
+    showMessage(text: string): void;
+}
+/**
+ * Type for the Javascript environment added by https://github.com/saasquatch/squatch-android
+ *
+ * Should exist as `window.SquatchAndroid`
+ */
+interface SquatchAndroid {
+    /**
+     *
+     * @param shareLink
+     * @param messageLink fallback URL to redirect to if the app is not installed
+     */
+    shareOnFacebook(shareLink: string, messageLink: string): void;
+    /**
+     * Shows a native Android toast
+     *
+     * @param text
+     */
+    showToast(text: string): void;
+}
+/**
+ * An interface provided by Squatch.js V2 for widgets.
+ *
+ * See: https://github.com/saasquatch/squatch-js/blob/8f2b218c9d55567e0cc12d27d635a5fb545e6842/src/widgets/Widget.ts#L47
+ *
+ */
+interface SquatchJS2 {
+    /**
+     * Opens the current popup widget (if loaded as a popup)
+     */
+    open?: () => void;
+    /**
+     * Closes the current popup widget (if loaded as a popup)
+     */
+    close?: () => void;
+    /**
+     * DEPRECATED used to update user details from inside the widget.
+     *
+     * Should no longer be used. Replace with natively using the GraphQL API and re-rendering locally. Will be removed in a future version of Squatch.js
+     *
+     * @deprecated
+     */
+    reload(userDetails: {
+        email: string;
+        firstName: string;
+        lastName: string;
+    }, jwt: string): void;
+}
+declare type Environment = EnvironmentSDK["type"];
+declare type EnvironmentSDK = {
+    type: "SquatchJS2";
+    api: SquatchJS2;
+    widgetIdent: WidgetIdent;
+} | {
+    type: "SquatchAndroid";
+    android: SquatchAndroid;
+    widgetIdent: WidgetIdent;
+} | {
+    type: "SquatchPortal";
+    env: PortalEnv;
+} | {
+    type: "SquatchAdmin";
+    adminSDK: SquatchAdmin;
+} | {
+    type: "None";
+};
+
+/**
+ * Get the type of environment that this widget is being rendered in
+ *
+ * Should never return null.
+ */
+declare function getEnvironment(): Environment;
+/**
+ * Get the SDK for interacting with the host environment
+ */
+declare function getEnvironmentSDK(): EnvironmentSDK;
+declare function isDemo(): boolean;
+declare function getTenantAlias(): string;
+declare function getAppDomain(): string;
+declare function getEngagementMedium(): EngagementMedium;
+
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+declare function setUserIdentity(identity?: UserIdentity): void;
+/**
+ * Get the current value of the user context
+ */
+declare function getUserIdentity(): UserIdentity | undefined;
+
+/**
+ * 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
+ */
+declare function lazilyStartLocaleContext(): ContextProvider<string | undefined>;
+/**
+ * Overide the globally defined Locale context
+ *
+ * @param locale the new locale used by the user
+ */
+declare function setLocale(locale?: string): void;
+/**
+ * Get the current value of the locale context
+ */
+declare function getLocale(): string | undefined;
+
+/**
+ * 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
+ */
+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
+ */
+declare function setProgramId(programId: string | undefined): void;
+/**
+ * Get the current value of the program context
+ */
+declare function getProgramId(): string | undefined;
+
+export { DEFAULT_MEDIUM, DecodedSquatchJWT, DecodedWidgetAPIJWT, EngagementMedium, Environment, EnvironmentSDK, LOCALE_CONTEXT_NAME, LocaleContextName, PROGRAM_CONTEXT_NAME, PortalEnv, ProgramContextName, SquatchAdmin, SquatchAndroid, SquatchJS2, USER_CONTEXT_NAME, UserContextName, UserId, UserIdentity, WidgetIdent, getAppDomain, getEngagementMedium, getEnvironment, getEnvironmentSDK, getLocale, getProgramId, getTenantAlias, getUserIdentity, isDemo, lazilyStartLocaleContext, lazilyStartProgramContext, lazilyStartUserContext, setLocale, setProgramId, setUserIdentity, userIdentityFromJwt };

package/dist/index.js

@@ -1,21 +1,432 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./environment"), exports);
-__exportStar(require("./contexts/UserIdentityContext"), exports);
-__exportStar(require("./contexts/LocaleContext"), exports);
-__exportStar(require("./contexts/ProgramContext"), exports);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_MEDIUM: () => DEFAULT_MEDIUM,
+  LOCALE_CONTEXT_NAME: () => LOCALE_CONTEXT_NAME,
+  PROGRAM_CONTEXT_NAME: () => PROGRAM_CONTEXT_NAME,
+  USER_CONTEXT_NAME: () => USER_CONTEXT_NAME,
+  getAppDomain: () => getAppDomain,
+  getEngagementMedium: () => getEngagementMedium,
+  getEnvironment: () => getEnvironment,
+  getEnvironmentSDK: () => getEnvironmentSDK,
+  getLocale: () => getLocale,
+  getProgramId: () => getProgramId,
+  getTenantAlias: () => getTenantAlias,
+  getUserIdentity: () => getUserIdentity,
+  isDemo: () => isDemo,
+  lazilyStartLocaleContext: () => lazilyStartLocaleContext,
+  lazilyStartProgramContext: () => lazilyStartProgramContext,
+  lazilyStartUserContext: () => lazilyStartUserContext,
+  setLocale: () => setLocale,
+  setProgramId: () => setProgramId,
+  setUserIdentity: () => setUserIdentity,
+  userIdentityFromJwt: () => userIdentityFromJwt
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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
+var import_jwt_decode = __toESM(require("jwt-decode"));
+var import_dom_context3 = require("dom-context");
+var import_equality = require("@wry/equality");
+
+// src/listeners.ts
+var import_dom_context2 = require("dom-context");
+
+// src/contexts/LocaleContext.ts
+var import_dom_context = require("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 import_dom_context.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 import_dom_context2.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;
+  },
+  onStatus: (status) => debug4("STATUS", status)
+});
+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 import_dom_context3.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);
+}
+function userIdentityFromJwt(jwt) {
+  if (!jwt)
+    return void 0;
+  try {
+    const decoded = (0, import_jwt_decode.default)(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 (!(0, import_equality.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
+var import_dom_context4 = require("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 import_dom_context4.ContextProvider({
+      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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});