@getuserfeedback/adapters 0.4.5 → 0.5.1

package/dist/gtm/template-generation.js

@@ -1,31 +1,37 @@
-import { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS, } from "@getuserfeedback/protocol";
-import { DEFAULT_GTM_SCOPE_MAPPINGS, ESSENTIAL_GTM_SCOPES, GTM_CONSENT_TYPES, GTM_TEMPLATE_MAPPING_OPTIONS, GTM_TEMPLATE_SCOPE_OPTIONS, isHostConfigurableGtmScope, } from "./core.js";
+import { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS } from "@getuserfeedback/protocol";
+import { GTM_CONSENT_TYPES } from "./core.js";
+import { BUILD_GTM_IDENTIFY_COMMAND_SOURCE, GTM_QUEUE_CLIENT_META, RESOLVE_GTM_THEME_INPUT_FROM_TEMPLATE_DATA_SOURCE, } from "./runtime-model.js";
 export const DEFAULT_GTM_LOADER_SCRIPT_BASE_URL = "https://cdn.getuserfeedback.com/widget/loader/v1";
 const GTM_TEMPLATE_VERSION = 1;
 const GTM_TEMPLATE_DEFAULT_DISPLAY_NAME = "getuserfeedback Widget";
-const GTM_TEMPLATE_DEFAULT_DESCRIPTION = "Load the getuserfeedback widget with Google Tag Manager, including theme settings and consent defaults.";
+const GTM_TEMPLATE_DEFAULT_DESCRIPTION = "Load the getuserfeedback widget with Google Tag Manager, including color scheme settings and user identity.";
+const GTM_TEMPLATE_DEFAULT_ID = "cvt_temp_public_id";
+const GTM_TEMPLATE_GALLERY_DISPLAY_NAME = "getuserfeedback.com";
+const GTM_TEMPLATE_GALLERY_DESCRIPTION = "In-app user onboarding, surveys, and embedded forms for feedback-fueled product growth";
+const GTM_TEMPLATE_DEFAULT_BRAND_DISPLAY_NAME = "getuserfeedback.com";
+const GTM_TEMPLATE_DEFAULT_BRAND_THUMBNAIL = "data:image/gif;base64,R0lGODlhAQABAAAAACwAAAAAAQABAAA=";
+const GTM_TEMPLATE_GALLERY_CATEGORIES = [
+    "CONVERSIONS",
+    "ANALYTICS",
+    "SURVEY",
+];
 const GTM_TEMPLATE_CATEGORIES = [
     "SURVEY",
     "PERSONALIZATION",
     "UTILITY",
 ];
 const GTM_TEMPLATE_CONTAINER_CONTEXTS = ["WEB"];
+const GTM_TEMPLATE_GALLERY_TERMS_OF_SERVICE = [
+    "By creating or modifying this file you agree to Google Tag Manager's Community",
+    "Template Gallery Developer Terms of Service available at",
+    "https://developers.google.com/tag-manager/gallery-tos (or such other URL as",
+    "Google may provide), as modified from time to time.",
+].join("\n");
+const GTM_TEMPLATE_DEFAULT_NOTES = "Generated from @getuserfeedback/adapters/gtm.";
+const GTM_TEMPLATE_DEFAULT_TESTS = "scenarios: []";
+const GTM_TEMPLATE_UTF8_BOM = "\uFEFF";
 const GTM_QUEUE_KEY = "__getuserfeedback_queue";
 const NON_EMPTY_VALIDATOR = { type: "NON_EMPTY" };
-const MANUAL_CONSENT_MODE_CONDITION = [
-    {
-        paramName: "consentMode",
-        paramValue: "manual",
-        type: "EQUALS",
-    },
-];
-const AUTOMATIC_CONSENT_MODE_CONDITION = [
-    {
-        paramName: "consentMode",
-        paramValue: "automatic",
-        type: "EQUALS",
-    },
-];
 const IDENTIFY_ADVANCED_MODE_CONDITION = [
     {
         paramName: "identifyMode",
@@ -49,6 +55,42 @@ const INTELLIGENT_IDENTIFY_EMAIL_KEYS = [
     "context.email",
     "context.user.email",
 ];
+const INTELLIGENT_IDENTIFY_FIRST_NAME_KEYS = [
+    "firstName",
+    "first_name",
+    "user.firstName",
+    "user.first_name",
+    "user.givenName",
+    "user.given_name",
+    "traits.firstName",
+    "traits.first_name",
+    "traits.givenName",
+    "traits.given_name",
+    "context.firstName",
+    "context.first_name",
+    "context.user.firstName",
+    "context.user.first_name",
+    "context.user.givenName",
+    "context.user.given_name",
+];
+const INTELLIGENT_IDENTIFY_LAST_NAME_KEYS = [
+    "lastName",
+    "last_name",
+    "user.lastName",
+    "user.last_name",
+    "user.familyName",
+    "user.family_name",
+    "traits.lastName",
+    "traits.last_name",
+    "traits.familyName",
+    "traits.family_name",
+    "context.lastName",
+    "context.last_name",
+    "context.user.lastName",
+    "context.user.last_name",
+    "context.user.familyName",
+    "context.user.family_name",
+];
 const INTELLIGENT_IDENTIFY_PHONE_KEYS = [
     "phone",
     "user.phone",
@@ -70,31 +112,6 @@ const ADVANCED_PRIMARY_IDENTITY_SELECT_ITEMS = [
         value: "email",
     },
 ];
-const buildAutomaticDefaultScopeMappings = () => DEFAULT_GTM_SCOPE_MAPPINGS.filter((mapping) => isHostConfigurableGtmScope(mapping.scope)).map((mapping) => ({
-    scope: mapping.scope,
-    mapping: mapping.consentType,
-}));
-const buildHostConfigurableDefaultScopeMappings = () => [
-    ...buildAutomaticDefaultScopeMappings(),
-    {
-        scope: "analytics.measurement",
-        mapping: "analytics_storage",
-    },
-];
-const buildScopeParameterHelp = () => [
-    "Some required widget storage settings are always enabled and do not appear here.",
-    `${ESSENTIAL_GTM_SCOPES[0]} and ${ESSENTIAL_GTM_SCOPES[1]} are always enabled so the widget can load and keep itself secure.`,
-    "",
-    ...GTM_TEMPLATE_SCOPE_OPTIONS.filter((option) => isHostConfigurableGtmScope(option.scope)).map((option) => `${option.label}: ${option.description}`),
-].join("\n");
-const buildHostConfigurableScopeSelectItems = () => GTM_TEMPLATE_SCOPE_OPTIONS.filter((option) => isHostConfigurableGtmScope(option.scope)).map((option) => ({
-    value: option.scope,
-    displayValue: option.label,
-}));
-const buildGtmConsentTypeSelectItems = () => GTM_TEMPLATE_MAPPING_OPTIONS.map((option) => ({
-    value: option.consentType,
-    displayValue: `${option.label} Granted`,
-}));
 const trimTrailingSlash = (value) => value.endsWith("/") ? value.slice(0, -1) : value;
 const stringValue = (value) => ({
     type: 1,
@@ -134,29 +151,61 @@ const buildPermission = (publicId, params) => ({
     },
     isRequired: true,
 });
+const normalizeAdditionalLoaderScriptUrlPatterns = (patterns) => {
+    if (!patterns) {
+        return [];
+    }
+    const normalizedPatterns = new Set();
+    for (const pattern of patterns) {
+        const normalizedPattern = pattern.trim();
+        if (!normalizedPattern) {
+            continue;
+        }
+        normalizedPatterns.add(normalizedPattern);
+    }
+    return [...normalizedPatterns];
+};
+const renderTemplateSection = (marker, content) => `${marker}\n\n${content}`;
+const normalizeTemplateStringSection = (value, fallback) => {
+    const normalizedValue = value?.trim();
+    return normalizedValue && normalizedValue.length > 0
+        ? normalizedValue
+        : fallback;
+};
+const normalizeTemplateStringArray = (value, fallback) => {
+    if (!value) {
+        return [...fallback];
+    }
+    const normalizedItems = [];
+    for (const item of value) {
+        const normalizedItem = item.trim();
+        if (normalizedItem.length === 0) {
+            continue;
+        }
+        normalizedItems.push(normalizedItem);
+    }
+    return normalizedItems.length > 0 ? normalizedItems : [...fallback];
+};
 export function buildGtmTemplateParameters(_options) {
-    const scopeHelp = buildScopeParameterHelp();
-    const scopeSelectItems = buildHostConfigurableScopeSelectItems();
-    const mappingSelectItems = buildGtmConsentTypeSelectItems();
     return [
         {
             type: "TEXT",
             name: "apiKey",
             displayName: "API Key",
             simpleValueType: true,
-            help: "Find your API key in getuserfeedback.com under Settings → Widget.",
+            help: "Paste your getuserfeedback API key from Settings → Widget.",
             valueValidators: [NON_EMPTY_VALIDATOR],
         },
         {
             type: "GROUP",
             name: "themeGroup",
-            displayName: "Theme Settings",
+            displayName: "Color Scheme",
             groupStyle: "ZIPPY_CLOSED",
             subParams: [
                 {
                     type: "SELECT",
                     name: "themeMode",
-                    displayName: "Theme Mode",
+                    displayName: "Color Scheme",
                     macrosInSelect: false,
                     selectItems: [
                         {
@@ -182,16 +231,16 @@ export function buildGtmTemplateParameters(_options) {
                     ],
                     simpleValueType: true,
                     defaultValue: "host",
-                    help: "Choose how the widget theme is set: use a fixed mode, follow your site's theme attributes, or read the value from a GTM variable.",
+                    help: "Choose how the widget color scheme should work.",
                 },
                 {
                     type: "SELECT",
                     name: "themeModeVariable",
-                    displayName: "Theme Mode Variable",
+                    displayName: "Color Scheme Variable",
                     macrosInSelect: true,
                     selectItems: [],
                     simpleValueType: true,
-                    help: "Use a GTM variable that resolves to `light`, `dark`, `system`, `auto`, or a comma-separated list of attribute names.",
+                    help: "Choose a GTM variable that returns `light`, `dark`, `system`, `auto`, or a comma-separated list of attribute names.",
                     enablingConditions: [
                         {
                             paramName: "themeMode",
@@ -204,10 +253,10 @@ export function buildGtmTemplateParameters(_options) {
                 {
                     type: "TEXT",
                     name: "themeAttr",
-                    displayName: "Host Theme Attributes",
+                    displayName: "Site Color Scheme Attributes",
                     simpleValueType: true,
                     defaultValue: DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS.join(","),
-                    help: "Comma-separated attributes to inspect on `<html>` or `<body>` when matching the widget theme to your site.",
+                    help: "Add the HTML or body attributes that show your site's color scheme, separated by commas.",
                     enablingConditions: [
                         {
                             paramName: "themeMode",
@@ -218,93 +267,6 @@ export function buildGtmTemplateParameters(_options) {
                 },
             ],
         },
-        {
-            type: "GROUP",
-            name: "consentGroup",
-            displayName: "Consent Settings",
-            groupStyle: "ZIPPY_CLOSED",
-            subParams: [
-                {
-                    type: "RADIO",
-                    name: "consentMode",
-                    displayName: "Consent Mode",
-                    radioItems: [
-                        {
-                            value: "automatic",
-                            displayValue: "Automatic (Use GTM Consent Mode)",
-                            help: "Use GTM consent checks to set the widget's initial consent state. This also lets you decide whether analytics measurement should follow analytics storage or use its own fixed setting.",
-                        },
-                        {
-                            value: "manual",
-                            displayValue: "Manual (Map Public Scopes)",
-                            help: "Choose which widget consent settings are granted for each GTM consent type. Required widget storage settings stay enabled and are not configurable here.",
-                        },
-                    ],
-                    simpleValueType: true,
-                    defaultValue: "automatic",
-                },
-                {
-                    type: "SELECT",
-                    name: "analyticsMeasurementMode",
-                    displayName: "Analytics Measurement Policy",
-                    macrosInSelect: false,
-                    selectItems: [
-                        {
-                            value: "inherit-analytics-storage",
-                            displayValue: "Inherit analytics_storage",
-                        },
-                        {
-                            value: "granted",
-                            displayValue: "Always granted",
-                        },
-                        {
-                            value: "denied",
-                            displayValue: "Always denied",
-                        },
-                    ],
-                    simpleValueType: true,
-                    defaultValue: "inherit-analytics-storage",
-                    help: [
-                        "Analytics measurement is separate from analytics storage so you can control event measurement independently.",
-                        "Inherit analytics_storage: `analytics.measurement` matches GTM `analytics_storage`.",
-                        "Always granted: `analytics.measurement` is always enabled.",
-                        "Always denied: `analytics.measurement` is always disabled.",
-                    ].join("\n"),
-                    enablingConditions: [...AUTOMATIC_CONSENT_MODE_CONDITION],
-                },
-                {
-                    type: "SIMPLE_TABLE",
-                    name: "scopeMappings",
-                    displayName: "Scope Mappings",
-                    simpleTableColumns: [
-                        {
-                            defaultValue: "analytics.storage",
-                            displayName: "Widget Scope",
-                            name: "scope",
-                            type: "SELECT",
-                            isUnique: true,
-                            selectItems: scopeSelectItems,
-                        },
-                        {
-                            defaultValue: "analytics_storage",
-                            displayName: "Granted When",
-                            name: "mapping",
-                            type: "SELECT",
-                            macrosInSelect: true,
-                            selectItems: mappingSelectItems,
-                        },
-                    ],
-                    newRowButtonText: "Add Scope",
-                    help: scopeHelp,
-                    enablingConditions: [...MANUAL_CONSENT_MODE_CONDITION],
-                    valueValidators: [NON_EMPTY_VALIDATOR],
-                    defaultValue: buildHostConfigurableDefaultScopeMappings().map((row) => ({
-                        scope: row.scope,
-                        mapping: row.mapping,
-                    })),
-                },
-            ],
-        },
         {
             type: "GROUP",
             name: "identifyGroup",
@@ -321,44 +283,44 @@ export function buildGtmTemplateParameters(_options) {
                         {
                             value: "intelligent",
                             displayValue: "Intelligent",
-                            help: "Automatically read common data layer keys for user ID, email, and phone. User ID is sent as `identify(userId)` and email or phone stay as raw traits.",
+                            help: "Automatically read common data layer keys for user ID, email, phone, first name, and last name.",
                         },
                         {
                             value: "disabled",
                             displayValue: "Disabled",
-                            help: "Do not send identify data from this GTM tag.",
+                            help: "Don't send identity data from this tag.",
                         },
                         {
                             value: "advanced",
-                            displayValue: "Advanced",
-                            help: "Choose how GTM encodes the primary identity and add any extra traits you want to send from GTM variables.",
+                            displayValue: "Custom",
+                            help: "Choose the main identity value and add any extra fields you want to send.",
                         },
                     ],
                 },
                 {
                     type: "SELECT",
                     name: "identifyPrimaryIdentityType",
-                    displayName: "Primary identity",
+                    displayName: "Main identity",
                     simpleValueType: true,
                     macrosInSelect: false,
                     defaultValue: "userId",
                     selectItems: [...ADVANCED_PRIMARY_IDENTITY_SELECT_ITEMS],
-                    help: "Choose whether GTM should encode the primary identity as `identify(userId)` or as a raw identity trait like `email` or `phone`.",
+                    help: "Choose whether the main identity should be sent as a user ID, email, or phone number.",
                     enablingConditions: [...IDENTIFY_ADVANCED_MODE_CONDITION],
                 },
                 {
                     type: "TEXT",
                     name: "identifyPrimaryIdentityValue",
-                    displayName: "Primary identity value",
+                    displayName: "Main identity value",
                     simpleValueType: true,
-                    help: "Use a GTM variable that resolves to the selected primary identity value.",
+                    help: "Choose a GTM variable for the main identity value.",
                     enablingConditions: [...IDENTIFY_ADVANCED_MODE_CONDITION],
                 },
                 {
                     type: "SIMPLE_TABLE",
                     name: "identifyTraits",
                     displayName: "Traits",
-                    help: "Add any traits you want to send from GTM variables. Common examples are `email`, `phone`, `name`, and `plan`. Empty rows are ignored.",
+                    help: "Add any extra fields you want to send from GTM variables. Common examples are `email`, `phone`, `firstName`, `lastName`, and `plan`. Empty rows are ignored.",
                     newRowButtonText: "Add Trait",
                     simpleTableColumns: [
                         {
@@ -380,8 +342,12 @@ export function buildGtmTemplateParameters(_options) {
 }
 export function buildGtmRuntimeSource(input) {
     const loaderScriptBaseUrl = trimTrailingSlash(input?.loaderScriptBaseUrl ?? DEFAULT_GTM_LOADER_SCRIPT_BASE_URL);
-    const automaticDefaultScopeMappings = buildAutomaticDefaultScopeMappings();
-    const defaultTemplateScopeMappings = buildHostConfigurableDefaultScopeMappings();
+    const runtimeEndpoints = input?.runtimeEndpoints === undefined
+        ? undefined
+        : {
+            apiUrl: input.runtimeEndpoints.apiUrl.trim(),
+            coreUrl: input.runtimeEndpoints.coreUrl.trim(),
+        };
     return `
 const log = require("logToConsole");
 const injectScript = require("injectScript");
@@ -393,14 +359,17 @@ const copyFromDataLayer = require("copyFromDataLayer");
 
 const loaderScriptBaseUrl = ${JSON.stringify(loaderScriptBaseUrl)};
 const gtmConsentTypes = ${JSON.stringify(GTM_CONSENT_TYPES)};
-const automaticDefaultScopeMappings = ${JSON.stringify(automaticDefaultScopeMappings)};
-const defaultScopeMappings = ${JSON.stringify(defaultTemplateScopeMappings)};
-const hostConfigurableScopes = ${JSON.stringify(defaultTemplateScopeMappings.map((row) => row.scope))};
 const defaultAutoDetectColorSchemeAttrs = ${JSON.stringify(DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS)};
 const queueKey = ${JSON.stringify(GTM_QUEUE_KEY)};
 const intelligentIdentifyUserIdKeys = ${JSON.stringify(INTELLIGENT_IDENTIFY_USER_ID_KEYS)};
 const intelligentIdentifyEmailKeys = ${JSON.stringify(INTELLIGENT_IDENTIFY_EMAIL_KEYS)};
+const intelligentIdentifyFirstNameKeys = ${JSON.stringify(INTELLIGENT_IDENTIFY_FIRST_NAME_KEYS)};
+const intelligentIdentifyLastNameKeys = ${JSON.stringify(INTELLIGENT_IDENTIFY_LAST_NAME_KEYS)};
 const intelligentIdentifyPhoneKeys = ${JSON.stringify(INTELLIGENT_IDENTIFY_PHONE_KEYS)};
+const generatedRuntimeEndpoints = ${JSON.stringify(runtimeEndpoints ?? null)};
+const queueClientMeta = ${JSON.stringify(GTM_QUEUE_CLIENT_META)};
+${RESOLVE_GTM_THEME_INPUT_FROM_TEMPLATE_DATA_SOURCE}
+${BUILD_GTM_IDENTIFY_COMMAND_SOURCE}
 
 const trimString = function(value) {
 	return typeof value === "string" ? value.trim() : "";
@@ -485,12 +454,7 @@ const normalizeTraitValue = function(value) {
 };
 
 const normalizeUserIdValue = function(value) {
-	if (typeof value !== "string") {
-		return undefined;
-	}
-
-	const trimmedValue = value.trim();
-	return trimmedValue ? trimmedValue : undefined;
+	return typeof value === "string" ? trimString(value) || undefined : undefined;
 };
 
 const addTrait = function(result, name, value) {
@@ -520,10 +484,12 @@ const getIntelligentIdentifyValue = function(keys) {
 };
 
 const getIntelligentIdentifyTraits = function() {
-	const traits = {};
-	addTrait(traits, "email", getIntelligentIdentifyValue(intelligentIdentifyEmailKeys));
-	addTrait(traits, "phone", getIntelligentIdentifyValue(intelligentIdentifyPhoneKeys));
-	return traits;
+	return {
+		email: getIntelligentIdentifyValue(intelligentIdentifyEmailKeys),
+		firstName: getIntelligentIdentifyValue(intelligentIdentifyFirstNameKeys),
+		lastName: getIntelligentIdentifyValue(intelligentIdentifyLastNameKeys),
+		phone: getIntelligentIdentifyValue(intelligentIdentifyPhoneKeys),
+	};
 };
 
 const getAdvancedIdentifyTraits = function(templateData) {
@@ -539,96 +505,27 @@ const getAdvancedIdentifyTraits = function(templateData) {
 	return traits;
 };
 
-const hasOwnKeys = function(value) {
-	for (const key in value) {
-		return !!key;
-	}
-	return false;
-};
-
-const getIdentifyCommandFromUserIdAndTraits = function(userId, traits) {
-	const hasTraits = hasOwnKeys(traits);
-
-	if (userId && hasTraits) {
-		return {
-			kind: "identify",
-			userId: userId,
-			traits: traits,
-		};
-	}
-	if (userId) {
-		return {
-			kind: "identify",
-			userId: userId,
-		};
-	}
-	if (hasTraits) {
-		return {
-			kind: "identify",
-			traits: traits,
-		};
-	}
-	return undefined;
-};
-
-const getIntelligentIdentifyCommand = function() {
-	const userId = normalizeUserIdValue(
-		getIntelligentIdentifyValue(intelligentIdentifyUserIdKeys),
-	);
-	const traits = getIntelligentIdentifyTraits();
-	return getIdentifyCommandFromUserIdAndTraits(userId, traits);
-};
-
-const getAdvancedIdentifyCommand = function(templateData) {
-	const traits = getAdvancedIdentifyTraits(templateData);
-	const primaryIdentityType = trimString(templateData.identifyPrimaryIdentityType);
-	const primaryIdentityValue = normalizeTraitValue(
-		templateData.identifyPrimaryIdentityValue,
-	);
-
-	if (primaryIdentityType === "userId") {
-		const userId = normalizeUserIdValue(primaryIdentityValue);
-		return getIdentifyCommandFromUserIdAndTraits(userId, traits);
-	}
-
-	if (
-		primaryIdentityType === "email" ||
-		primaryIdentityType === "phone"
-	) {
-		addTrait(traits, primaryIdentityType, primaryIdentityValue);
-	}
-
-	return hasOwnKeys(traits)
-		? {
-				kind: "identify",
-				traits: traits,
-			}
-		: undefined;
-};
-
 const getIdentifyCommand = function(templateData) {
 	if (templateData.identifyMode === "intelligent") {
-		return getIntelligentIdentifyCommand();
+		const intelligentTraits = getIntelligentIdentifyTraits();
+		return buildGtmIdentifyCommand({
+			email: intelligentTraits.email,
+			firstName: intelligentTraits.firstName,
+			lastName: intelligentTraits.lastName,
+			mode: "intelligent",
+			phone: intelligentTraits.phone,
+			userId: getIntelligentIdentifyValue(intelligentIdentifyUserIdKeys),
+		});
 	}
 	if (templateData.identifyMode === "advanced") {
-		return getAdvancedIdentifyCommand(templateData);
-	}
-	return undefined;
-};
-
-const getThemeInput = function(templateData) {
-	if (templateData.themeMode === "variable") {
-		return templateData.themeModeVariable;
-	}
-	if (templateData.themeMode === "host") {
-		return templateData.themeAttr;
-	}
-	if (
-		templateData.themeMode === "light" ||
-		templateData.themeMode === "dark" ||
-		templateData.themeMode === "system"
-	) {
-		return templateData.themeMode;
+		return buildGtmIdentifyCommand({
+			mode: "advanced",
+			primaryIdentityType: trimString(templateData.identifyPrimaryIdentityType),
+			primaryIdentityValue: normalizeTraitValue(
+				templateData.identifyPrimaryIdentityValue,
+			),
+			traits: getAdvancedIdentifyTraits(templateData),
+		});
 	}
 	return undefined;
 };
@@ -644,144 +541,78 @@ const getConsentState = function() {
 	return result;
 };
 
-const dedupeScopes = function(scopes) {
-	const seen = {};
-	const result = [];
-	for (let index = 0; index < scopes.length; index += 1) {
-		const scope = scopes[index];
-		if (typeof scope !== "string" || seen[scope]) {
-			continue;
+const buildDefaultConsent = function(templateData) {
+	const consentState = getConsentState();
+	const grantedScopeLookup = {};
+	const grantedScopes = [];
+	const grantScope = function(scope) {
+		if (!scope || grantedScopeLookup[scope]) {
+			return;
 		}
-		seen[scope] = true;
-		result.push(scope);
-	}
-	return result;
-};
+		grantedScopeLookup[scope] = true;
+		grantedScopes.push(scope);
+	};
 
-const isKnownConsentType = function(consentType) {
-	for (let index = 0; index < gtmConsentTypes.length; index += 1) {
-		if (gtmConsentTypes[index] === consentType) {
-			return true;
-		}
+	if (consentState.analytics_storage === "granted") {
+		grantScope("analytics.storage");
+		grantScope("analytics.measurement");
 	}
-	return false;
-};
-
-const isHostConfigurableScope = function(scope) {
-	for (let index = 0; index < hostConfigurableScopes.length; index += 1) {
-		if (hostConfigurableScopes[index] === scope) {
-			return true;
-		}
+	if (consentState.personalization_storage === "granted") {
+		grantScope("personalization.storage");
 	}
-	return false;
-};
-
-const getManualScopeMappings = function(templateData) {
-	const rawRows = getSimpleTableRows(templateData.scopeMappings);
-	const rows = rawRows.length > 0 ? rawRows : defaultScopeMappings;
-	const mappings = [];
-	for (let index = 0; index < rows.length; index += 1) {
-		const row = rows[index];
-		if (!row || typeof row !== "object") {
-			continue;
-		}
-		const scope = trimString(row.scope);
-		const consentType = trimString(row.mapping);
-		if (!scope || !consentType) {
-			continue;
-		}
-		if (!isHostConfigurableScope(scope) || !isKnownConsentType(consentType)) {
-			continue;
-		}
-		mappings.push({
-			scope: scope,
-			consentType: consentType,
-		});
+	if (consentState.ad_storage === "granted") {
+		grantScope("ads.storage");
 	}
-	return mappings;
-};
-
-const getAnalyticsMeasurementMode = function(templateData) {
-	if (
-		templateData.analyticsMeasurementMode === "granted" ||
-		templateData.analyticsMeasurementMode === "denied"
-	) {
-		return templateData.analyticsMeasurementMode;
+	if (consentState.ad_user_data === "granted") {
+		grantScope("ads.user_data");
 	}
-	return "inherit-analytics-storage";
-};
-
-const buildDefaultConsent = function(templateData) {
-	const consentState = getConsentState();
-	const grantedScopes = [];
-
-	if (templateData.consentMode === "manual") {
-		const scopeMappings = getManualScopeMappings(templateData);
-		for (let index = 0; index < scopeMappings.length; index += 1) {
-			const mapping = scopeMappings[index];
-			if (consentState[mapping.consentType] === "granted") {
-				grantedScopes.push(mapping.scope);
-			}
-		}
-	} else {
-		for (let index = 0; index < automaticDefaultScopeMappings.length; index += 1) {
-			const mapping = automaticDefaultScopeMappings[index];
-			if (consentState[mapping.mapping] === "granted") {
-				grantedScopes.push(mapping.scope);
-			}
-		}
-
-		const analyticsMeasurementMode = getAnalyticsMeasurementMode(templateData);
-		if (analyticsMeasurementMode === "granted") {
-			grantedScopes.push("analytics.measurement");
-		}
-		if (
-			analyticsMeasurementMode === "inherit-analytics-storage" &&
-			consentState.analytics_storage === "granted"
-		) {
-			grantedScopes.push("analytics.measurement");
-		}
+	if (consentState.ad_personalization === "granted") {
+		grantScope("ads.personalization");
 	}
 
-	const dedupedScopes = dedupeScopes(grantedScopes);
-	return dedupedScopes.length > 0 ? dedupedScopes : undefined;
+	return grantedScopes.length > 0 ? grantedScopes : undefined;
 };
 
-const onSuccess = function() {
-	if (typeof data.gtmOnSuccess === "function") {
-		data.gtmOnSuccess();
-	}
+let requestSequence = 0;
+
+const enqueuePublicCommand = function(queuePush, instanceId, command) {
+	requestSequence += 1;
+	const requestId = "gtm_" + command.kind + "_" + requestSequence;
+	queuePush({
+		version: "1",
+		instanceId: instanceId,
+		requestId: requestId,
+		idempotencyKey: requestId,
+		clientMeta: queueClientMeta,
+		command: command,
+	});
 };
 
-const onFailure = function() {
+const apiKey = trimString(data.apiKey);
+if (!apiKey) {
 	if (typeof data.gtmOnFailure === "function") {
 		data.gtmOnFailure();
 	}
-};
-
-const apiKey = trimString(data.apiKey);
-if (!apiKey) {
-	onFailure();
 	return;
 }
 
 const encodedApiKey = encodeUriComponent(apiKey);
 if (!encodedApiKey) {
-	onFailure();
+	if (typeof data.gtmOnFailure === "function") {
+		data.gtmOnFailure();
+	}
 	return;
 }
-
 const widgetUrl = loaderScriptBaseUrl + "/" + encodedApiKey + "/loader.js";
 const queuePush = createQueue(queueKey);
+const instanceId = "gtm-" + encodedApiKey;
 const initOptions = {
 	apiKey: apiKey,
-	clientMeta: {
-		loader: "gtm",
-		transport: "tag-manager",
-	},
+	clientMeta: queueClientMeta,
 };
 
-const colorScheme = normalizeThemeInput(getThemeInput(data));
+const themeInput = resolveGtmThemeInputFromTemplateData(data);
+const colorScheme = normalizeThemeInput(themeInput);
 if (colorScheme !== undefined) {
 	initOptions.colorScheme = colorScheme;
 }
@@ -791,33 +622,50 @@ if (defaultConsent !== undefined) {
 	initOptions.defaultConsent = defaultConsent;
 }
 
-queuePush({
+if (generatedRuntimeEndpoints !== null) {
+	initOptions.runtimeEndpoints = {
+		apiUrl: generatedRuntimeEndpoints.apiUrl,
+		coreUrl: generatedRuntimeEndpoints.coreUrl,
+	};
+}
+
+enqueuePublicCommand(queuePush, instanceId, {
 	kind: "init",
 	opts: initOptions,
 });
 
 const identifyCommand = getIdentifyCommand(data);
 if (identifyCommand !== undefined) {
-	queuePush(identifyCommand);
+	enqueuePublicCommand(queuePush, instanceId, identifyCommand);
 }
 
 log("Loading getuserfeedback loader:", widgetUrl);
 
 if (queryPermission("inject_script", widgetUrl)) {
-	injectScript(widgetUrl, onSuccess, onFailure, "getuserfeedback");
+	injectScript(
+		widgetUrl,
+		typeof data.gtmOnSuccess === "function" ? data.gtmOnSuccess : undefined,
+		typeof data.gtmOnFailure === "function" ? data.gtmOnFailure : undefined,
+		"getuserfeedback",
+	);
 } else {
-	onFailure();
+	if (typeof data.gtmOnFailure === "function") {
+		data.gtmOnFailure();
+	}
 }
 `.trim();
 }
 export function buildGtmPermissions(input) {
     const loaderScriptBaseUrl = trimTrailingSlash(input?.loaderScriptBaseUrl ?? DEFAULT_GTM_LOADER_SCRIPT_BASE_URL);
-    const loaderUrlPattern = `${loaderScriptBaseUrl}/*/loader.js`;
+    const loaderUrlPatterns = [
+        `${loaderScriptBaseUrl}/*/loader.js`,
+        ...normalizeAdditionalLoaderScriptUrlPatterns(input?.additionalLoaderScriptUrlPatterns),
+    ];
     return [
         buildPermission("inject_script", [
             {
                 key: "urls",
-                value: listValue([stringValue(loaderUrlPattern)]),
+                value: listValue(loaderUrlPatterns.map((pattern) => stringValue(pattern))),
             },
         ]),
         buildPermission("logging", [
@@ -855,6 +703,8 @@ export function buildGtmPermissions(input) {
                 value: listValue([
                     ...INTELLIGENT_IDENTIFY_USER_ID_KEYS,
                     ...INTELLIGENT_IDENTIFY_EMAIL_KEYS,
+                    ...INTELLIGENT_IDENTIFY_FIRST_NAME_KEYS,
+                    ...INTELLIGENT_IDENTIFY_LAST_NAME_KEYS,
                     ...INTELLIGENT_IDENTIFY_PHONE_KEYS,
                 ].map((key) => stringValue(key))),
             },
@@ -882,3 +732,32 @@ export function buildGtmTemplateParts(input) {
 export function buildGtmTemplateArtifact(input) {
     return buildGtmTemplateParts(input);
 }
+export function buildGtmTemplateFileSource(input) {
+    const artifact = buildGtmTemplateArtifact(input);
+    const infoOverrides = input?.infoOverrides;
+    const info = {
+        type: artifact.info.type,
+        id: normalizeTemplateStringSection(infoOverrides?.id, GTM_TEMPLATE_DEFAULT_ID),
+        version: artifact.info.version,
+        securityGroups: normalizeTemplateStringArray(infoOverrides?.securityGroups, []),
+        displayName: normalizeTemplateStringSection(infoOverrides?.displayName, GTM_TEMPLATE_GALLERY_DISPLAY_NAME),
+        categories: normalizeTemplateStringArray(infoOverrides?.categories, GTM_TEMPLATE_GALLERY_CATEGORIES),
+        brand: {
+            displayName: normalizeTemplateStringSection(infoOverrides?.brandDisplayName, GTM_TEMPLATE_DEFAULT_BRAND_DISPLAY_NAME),
+            thumbnail: normalizeTemplateStringSection(infoOverrides?.brandThumbnail, GTM_TEMPLATE_DEFAULT_BRAND_THUMBNAIL),
+        },
+        description: normalizeTemplateStringSection(infoOverrides?.description, GTM_TEMPLATE_GALLERY_DESCRIPTION),
+        containerContexts: [...artifact.info.containerContexts],
+    };
+    const sections = [
+        renderTemplateSection("___TERMS_OF_SERVICE___", normalizeTemplateStringSection(input?.termsOfService, GTM_TEMPLATE_GALLERY_TERMS_OF_SERVICE)),
+        renderTemplateSection("___INFO___", JSON.stringify(info, null, 2)),
+        renderTemplateSection("___TEMPLATE_PARAMETERS___", JSON.stringify(artifact.parameters, null, 2)),
+        renderTemplateSection("___SANDBOXED_JS_FOR_WEB_TEMPLATE___", artifact.runtimeSource),
+        renderTemplateSection("___WEB_PERMISSIONS___", JSON.stringify(artifact.permissions, null, 2)),
+        renderTemplateSection("___TESTS___", normalizeTemplateStringSection(input?.tests, GTM_TEMPLATE_DEFAULT_TESTS)),
+        renderTemplateSection("___NOTES___", normalizeTemplateStringSection(input?.notes, GTM_TEMPLATE_DEFAULT_NOTES)),
+        "",
+    ];
+    return `${input?.includeUtf8Bom === false ? "" : GTM_TEMPLATE_UTF8_BOM}${sections.join("\n\n")}`;
+}