@adobe/alloy 2.28.0 → 2.28.1-beta.0

package/libEs6/utils/validation/index.js

@@ -0,0 +1,236 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Validators are functions of two parameters (value and path) that return the
+ * computed value if the input is valid, or throw an exception if the input is
+ * invalid. In most cases the returned value is the same as the input value;
+ * however, reference createDefaultValidator.js to see an example where the
+ * computed value is different from the input. Additionally, if we ever wanted
+ * to coerce types (i.e. parse string values into integers) as part of the
+ * validation process we could use the computed value to accomplish that.
+ *
+ * The path parameter is used to generate informative error messages. It is
+ * created by the objectOf, and arrayOf validators so that any error message can
+ * describe which key within the object or array is invalid.
+ *
+ * The validators also have methods to chain additional validation logic. For
+ * example, when you call `string()` to start a validator chain, it returns a
+ * validator function but it also has methods like `required` and `nonEmpty`.
+ * Here you can see that these methods are actually calling `chain`.
+ * Specifically in this function, the leftValidator is called first and then the
+ * return value of that is sent to the rightValidator. For example, when calling
+ * `string().nonEmpty().required()` the following chain is built up:
+ * ```
+ *              *
+ *            /   \
+ *          *     required
+ *        /   \
+ *      *     nonEmpty
+ *    /   \
+ * base   string
+ * ```
+ * Where every * is a call to chain where the two are combined. The individual
+ * validators are called from left to right in the above tree. The base
+ * validator is simply the identity function `value => value`, representing an
+ * optional value.
+ *
+ * After combining the validators, the new validator function is then augmented
+ * with the methods from the leftValidator and from the additionalMethods
+ * parameter. For example, when the string() function is called it chains to the
+ * base validator, but also adds additional methods like (`regexp`, `domain`,
+ * `nonEmpty`, and `unique`). When `nonEmpty` is called, which calls chain
+ * again, the additional methods are carried forward because they are already
+ * defined on the leftValidator.
+ *
+ * The base validator also contains the two methods `required` and `default`, so
+ * these can be used anywhere after any of the exposed validator functions are
+ * called.
+ *
+ * For most validators, we want the validation to be optional (i.e. allow null
+ * or undefined values). To accomplish this, the validator needs to have a check
+ * at the begining of the function, short circuiting the validation logic and
+ * returning value if value is null or undefined. `default` and `required` do
+ * not want this null check though. Indeed, `default` should return the default
+ * value if value is null, and `required` should throw an error if value is
+ * null.
+ *
+ * So to keep from having to have a null check in front of most validators,
+ * nullSafeChain allows you to chain a validator in a null-safe way.
+ */
+
+import { chain, nullSafeChain, reverseNullSafeChainJoinErrors } from "./utils.js";
+import booleanValidator from "./booleanValidator.js";
+import callbackValidator from "./callbackValidator.js";
+import createAnyOfValidator from "./createAnyOfValidator.js";
+import createArrayOfValidator from "./createArrayOfValidator.js";
+import createDefaultValidator from "./createDefaultValidator.js";
+import createDeprecatedValidator from "./createDeprecatedValidator.js";
+import createLiteralValidator from "./createLiteralValidator.js";
+import createMapOfValuesValidator from "./createMapOfValuesValidator.js";
+import createMinimumValidator from "./createMinimumValidator.js";
+import createMaximumValidator from "./createMaximumValidator.js";
+import createNoUnknownFieldsValidator from "./createNoUnknownFieldsValidator.js";
+import createNonEmptyValidator from "./createNonEmptyValidator.js";
+import createObjectOfValidator from "./createObjectOfValidator.js";
+import createRenamedValidator from "./createRenamedValidator.js";
+import createUniqueValidator from "./createUniqueValidator.js";
+import createUniqueItemsValidator from "./createUniqueItemsValidator.js";
+import domainValidator from "./domainValidator.js";
+import integerValidator from "./integerValidator.js";
+import numberValidator from "./numberValidator.js";
+import regexpValidator from "./regexpValidator.js";
+import requiredValidator from "./requiredValidator.js";
+import stringValidator from "./stringValidator.js";
+import matchesRegexpValidator from "./matchesRegexpValidator.js";
+
+// The base validator does no validation and just returns the value unchanged
+const base = value => value;
+
+// The 'default', 'required', and 'deprecated' methods are available after any
+// data-type method. Don't use the nullSafeChain on 'default' or 'required'
+// because they need to handle the null or undefined case
+base.default = function _default(defaultValue) {
+  return chain(this, createDefaultValidator(defaultValue));
+};
+base.required = function required() {
+  return chain(this, requiredValidator);
+};
+base.deprecated = function deprecated(message) {
+  return chain(this, createDeprecatedValidator(message));
+};
+
+// helper validators
+const domain = function domain() {
+  return nullSafeChain(this, domainValidator);
+};
+const minimumInteger = function minimumInteger(minValue) {
+  return nullSafeChain(this, createMinimumValidator("an integer", minValue));
+};
+const minimumNumber = function minimumNumber(minValue) {
+  return nullSafeChain(this, createMinimumValidator("a number", minValue));
+};
+const maximumNumber = function maximumNumber(maxValue) {
+  return nullSafeChain(this, createMaximumValidator("a number", maxValue));
+};
+const integer = function integer() {
+  return nullSafeChain(this, integerValidator, {
+    minimum: minimumInteger
+  });
+};
+const nonEmptyString = function nonEmptyString() {
+  return nullSafeChain(this, createNonEmptyValidator("a non-empty string"));
+};
+const nonEmptyArray = function nonEmptyArray() {
+  return nullSafeChain(this, createNonEmptyValidator("a non-empty array"));
+};
+const nonEmptyObject = function nonEmptyObject() {
+  return nullSafeChain(this, createNonEmptyValidator("a non-empty object"));
+};
+const regexp = function regexp() {
+  return nullSafeChain(this, regexpValidator);
+};
+const matches = function matches(regexpPattern) {
+  return nullSafeChain(this, matchesRegexpValidator(regexpPattern));
+};
+const unique = function createUnique() {
+  return nullSafeChain(this, createUniqueValidator());
+};
+const uniqueItems = function createUniqueItems() {
+  return nullSafeChain(this, createUniqueItemsValidator());
+};
+
+// top-level validators.  These are the first functions that are called to create a validator.
+const anyOf = function anyOf(validators, message) {
+  // use chain here because we don't want to accept null or undefined unless at least
+  // one of the validators accept null or undefined.
+  return chain(this, createAnyOfValidator(validators, message));
+};
+const anything = function anything() {
+  return this;
+};
+const arrayOf = function arrayOf(elementValidator) {
+  return nullSafeChain(this, createArrayOfValidator(elementValidator), {
+    nonEmpty: nonEmptyArray,
+    uniqueItems
+  });
+};
+const boolean = function boolean() {
+  return nullSafeChain(this, booleanValidator);
+};
+const callback = function callback() {
+  return nullSafeChain(this, callbackValidator);
+};
+const literal = function literal(literalValue) {
+  return nullSafeChain(this, createLiteralValidator(literalValue));
+};
+const number = function number() {
+  return nullSafeChain(this, numberValidator, {
+    minimum: minimumNumber,
+    maximum: maximumNumber,
+    integer,
+    unique
+  });
+};
+const mapOfValues = function mapOfValues(valuesValidator) {
+  return nullSafeChain(this, createMapOfValuesValidator(valuesValidator), {
+    nonEmpty: nonEmptyObject
+  });
+};
+const createObjectOfAdditionalProperties = schema => ({
+  noUnknownFields: function noUnknownFields() {
+    return nullSafeChain(this, createNoUnknownFieldsValidator(schema));
+  },
+  nonEmpty: nonEmptyObject,
+  concat: function concat(otherObjectOfValidator) {
+    // combine the schema so that noUnknownFields, and concat have the combined schema
+    const newSchema = {
+      ...schema,
+      ...otherObjectOfValidator.schema
+    };
+    return nullSafeChain(this, otherObjectOfValidator, createObjectOfAdditionalProperties(newSchema));
+  },
+  renamed: function renamed(oldField, oldSchema, newField) {
+    // Run the deprecated validator first so that the deprecated field is removed
+    // before the objectOf validator runs.
+    return reverseNullSafeChainJoinErrors(this, createRenamedValidator(oldField, oldSchema, newField));
+  },
+  schema
+});
+const objectOf = function objectOf(schema) {
+  return nullSafeChain(this, createObjectOfValidator(schema), createObjectOfAdditionalProperties(schema));
+};
+const string = function string() {
+  return nullSafeChain(this, stringValidator, {
+    regexp,
+    domain,
+    nonEmpty: nonEmptyString,
+    unique,
+    matches
+  });
+};
+const boundAnyOf = anyOf.bind(base);
+const boundAnything = anything.bind(base);
+const boundArrayOf = arrayOf.bind(base);
+const boundBoolean = boolean.bind(base);
+const boundCallback = callback.bind(base);
+const boundLiteral = literal.bind(base);
+const boundNumber = number.bind(base);
+const boundMapOfValues = mapOfValues.bind(base);
+const boundObjectOf = objectOf.bind(base);
+const boundString = string.bind(base);
+
+// compound validators
+const boundEnumOf = function boundEnumOf(...values) {
+  return boundAnyOf(values.map(boundLiteral), `one of these values: ${JSON.stringify(values)}`);
+};
+export { boundAnyOf as anyOf, boundAnything as anything, boundArrayOf as arrayOf, boundBoolean as boolean, boundCallback as callback, boundLiteral as literal, boundNumber as number, boundMapOfValues as mapOfValues, boundObjectOf as objectOf, boundString as string, boundEnumOf as enumOf };

package/libEs6/utils/validation/integerValidator.js

@@ -0,0 +1,18 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import isInteger from "../isInteger.js";
+import { assertValid } from "./utils.js";
+export default (value, path) => {
+  assertValid(isInteger(value), value, path, "an integer");
+  return value;
+};

package/libEs6/utils/validation/matchesRegexpValidator.js

@@ -0,0 +1,17 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { assertValid } from "./utils.js";
+export default regexp => (value, path) => {
+  assertValid(regexp.test(value), value, path, `does not match the ${regexp.toString()}`);
+  return value;
+};

package/libEs6/utils/validation/numberValidator.js

@@ -0,0 +1,18 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import isNumber from "../isNumber.js";
+import { assertValid } from "./utils.js";
+export default (value, path) => {
+  assertValid(isNumber(value), value, path, "a number");
+  return value;
+};

package/libEs6/utils/validation/regexpValidator.js

@@ -0,0 +1,18 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { assertValid } from "./utils.js";
+import isValidRegExp from "../isValidRegExp.js";
+export default (value, path) => {
+  assertValid(isValidRegExp(value), value, path, "a regular expression");
+  return value;
+};

package/libEs6/utils/validation/requiredValidator.js

@@ -0,0 +1,18 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export default (value, path) => {
+  if (value == null) {
+    throw new Error(`'${path}' is a required option`);
+  }
+  return value;
+};

package/libEs6/utils/validation/stringValidator.js

@@ -0,0 +1,17 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import isString from "../isString.js";
+import { assertValid } from "./utils.js";
+export default (value, path) => {
+  assertValid(isString(value), value, path, "a string");
+  return value;
+};

package/libEs6/utils/validation/utils.js

@@ -0,0 +1,124 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+/**
+ * Wraps a validator returning the value if it is null or undefined, otherwise
+ * it will call the original validator and return the result.
+ *
+ * @param {function} validator - the validator to call if the value is not null
+ */
+const skipIfNull = validator => function skipIfNullValidator(value, path) {
+  return value == null ? value : validator.call(this, value, path);
+};
+
+/**
+ * Returns a new validator that calls the first validator and then calls the second
+ * validator with the result of the first validator. The result of the second validator
+ * is returned.
+ *
+ * @param {function} firstValidator - validator to call first
+ * @param {function} secondValidator - validator to call second
+ * @returns {function} - a new validator that calls the first and second validators
+ */
+const callSequentially = (firstValidator, secondValidator) => function callSequentiallyValidator(value, path) {
+  return secondValidator.call(this, firstValidator.call(this, value, path), path);
+};
+
+/**
+ * Just like callSequentially, but if either validator throws an error, the errors
+ * are collected and thrown at the end.
+ *
+ * @param {function} firstValidator
+ * @param {function} secondValidator
+ * @returns {function}
+ */
+const callSequentiallyJoinErrors = (firstValidator, secondValidator) => function callSequentiallyJoinErrorsValidator(value, path) {
+  const errors = [];
+  const newValue = [firstValidator, secondValidator].reduce((memo, validator) => {
+    try {
+      return validator.call(this, memo, path);
+    } catch (e) {
+      errors.push(e);
+      return memo;
+    }
+  }, value);
+  if (errors.length) {
+    throw new Error(errors.join("\n"));
+  }
+  return newValue;
+};
+
+/**
+ * Chains two validators together. In addition to calling the validators in
+ * sequence, this will also copy over methods from the base validator to the
+ * resulting validator and include any additional methods.
+ *
+ * @param {function} baseValidator - This validator will be called first, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called second.
+ * @param {object} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+export const chain = (baseValidator, newValidator, additionalMethods) => {
+  return Object.assign(callSequentially(baseValidator, newValidator), baseValidator, additionalMethods);
+};
+
+/**
+ * Chains two validators together, but skips the second validator if the value
+ * is null. In addition to calling the validators in sequence, this will also
+ * copy over methods from the base validator to the resulting validator and
+ * include any additional methods.
+ *
+ * @param {function} baseValidator - This validator will be called first, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called second. If the value
+ * is null after the first validator is called, this validator will not be
+ * called.
+ * @param {object} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+export const nullSafeChain = (baseValidator, newValidator, additionalMethods) => {
+  return Object.assign(callSequentially(baseValidator, skipIfNull(newValidator)), baseValidator, additionalMethods);
+};
+
+/**
+ * Same as nullSafeChain, but calls the new validator first.
+ *
+ * @param {function} baseValidator - This validator will be called second, and its
+ * methods will be copied over to the returned validator.
+ * @param {function} newValidator - This validator will be called first. If the value
+ * is null, this validator will not be called.
+ * @param {function} additionalMethods - Additional methods to include on the returned
+ * validator.
+ * @returns {function}
+ */
+export const reverseNullSafeChainJoinErrors = (baseValidator, newValidator, additionalMethods) => {
+  return Object.assign(callSequentiallyJoinErrors(skipIfNull(newValidator), baseValidator), baseValidator, additionalMethods);
+};
+
+/**
+ * Throws an error if the value is not valid.
+ *
+ * @param {boolean} isValid - Whether or not the value is valid.
+ * @param {*} value - The value to validate.
+ * @param {string} path - The path to the value.
+ * @param {string} message - The expected part of the error message.
+ * @throws {Error} - Throws an error if the value is not valid.
+ * @returns {void}
+ */
+export const assertValid = (isValid, value, path, message) => {
+  if (!isValid) {
+    throw new Error(`'${path}': Expected ${message}, but got ${JSON.stringify(value)}.`);
+  }
+};

package/package.json

@@ -1,58 +1,56 @@
 {
   "name": "@adobe/alloy",
-  "version": "2.28.0",
+  "version": "2.28.1-beta.0",
   "description": "Adobe Experience Platform Web SDK",
   "type": "module",
-  "main": "dist/alloy.cjs",
-  "module": "dist/alloy.js",
-  "types": "dist/types/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/alloy.js",
-      "require": "./dist/alloy.cjs"
-    },
-    "./utils": {
-      "types": "./dist/types/utils/index.d.ts",
-      "import": "./dist/utils.js",
-      "require": "./dist/utils.cjs"
-    }
-  },
+  "main": "libEs5/index.js",
+  "module": "libEs6/index.js",
+  "types": "types/index.d.ts",
   "files": [
-    "dist",
+    "libEs5",
+    "libEs6",
+    "types",
     "LICENSE_BANNER",
+    "babel.config.js",
     "rollup.config.js",
     ".browserslistrc",
-    "src/core/componentCreators.js",
     "scripts/helpers/entryPointGeneratorBabelPlugin.js",
+    "scripts/helpers/versionBabelPlugin.js",
     "scripts/helpers/path.js"
   ],
   "bin": {
     "alloyBuilder": "scripts/alloyBuilder.js"
   },
   "scripts": {
-    "clean": "rimraf dist",
+    "clean": "rimraf dist distTest libEs5 libEs6 types",
     "lint": "eslint --cache --fix \"*.{js,cjs,mjs,jsx}\" \"{src,test,scripts,sandbox}/**/*.{js,cjs,mjs,jsx}\"",
     "format": "prettier --write \"*.{html,js,cjs,mjs,jsx}\" \"{sandbox,src,test,scripts}/**/*.{html,js,cjs,mjs,jsx}\"",
     "types": "tsc",
-    "test": "npx playwright install chromium && npm run test:build && vitest run --silent && npm run test:scripts",
-    "test:build": "rollup -c --environment SOURCEMAP",
-    "test:coverage": "rimraf coverage && npx playwright install chromium && npm run test:build && vitest run --coverage --silent",
-    "test:unit": "npx playwright install chromium && vitest --project=unit --run",
-    "test:unit:debug": "npm run test:unit -- --no-run --no-file-parallelism --browser=chromium --browser.provider=playwright --browser.headless=false",
-    "pretest:integration": "npm run test:build",
-    "test:integration": "npx playwright install chromium && vitest --project=integration --run --silent",
-    "test:integration:debug": "npm run test:integration -- --no-run --no-file-parallelism --browser=chromium --browser.provider=playwright --browser.headless=false",
+    "test": "npx playwright install chromium && vitest run && npm run test:scripts",
+    "test:coverage": "rimraf coverage && npx playwright install chromium && vitest run --coverage",
+    "test:unit": "npx playwright install chromium && vitest run --project=unit",
+    "test:unit:debug": "npx playwright install chromium && vitest --no-file-parallelism --project=unit --browser=chromium --browser.provider=playwright --browser.headless=false",
+    "test:unit:watch": "npx playwright install chromium && vitest --project=unit",
+    "test:unit:coverage": "npx playwright install chromium && vitest run --coverage --project=unit",
+    "test:integration": "npx playwright install chromium && vitest run --project=integration",
+    "test:integration:debug": "npx playwright install chromium && vitest --no-file-parallelism --project=integration --browser=chromium --browser.provider=playwright --browser.headless=false",
+    "test:integration:watch": "npx playwright install chromium && vitest --project=integration",
+    "test:integration:coverage": "npx playwright install chromium && vitest run --coverage --project=integration",
     "test:functional": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" testcafe chrome",
+    "test:functional:custom": "node scripts/helpers/runFunctionalTests.js",
     "test:functional:watch": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" ./scripts/watchFunctionalTests.js --browsers chrome",
-    "test:functional:debug": "npm run test:functional -- --debug-mode",
+    "test:functional:debug": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" testcafe --inspect-brk chrome",
+    "test:functional:build:int": "rollup -c --environment BASE_CODE_MIN,STANDALONE,NPM_PACKAGE_LOCAL",
+    "test:functional:build:prod": "rollup -c --environment BASE_CODE_MIN,NPM_PACKAGE_PROD",
     "test:scripts": "vitest run --config=./scripts/specs/vitest.config.js",
-    "dev": "cd sandbox && export REACT_APP_NONCE=321 && npm start",
-    "build": "npm run clean && rollup -c --environment BUNDLESIZE && npm run types && echo \"Base Code:\" && cat dist/baseCode.min.js",
-    "build:watch": "npm run clean && rollup -c --watch",
+    "sandbox:build": "rollup -c --environment SANDBOX && cd sandbox && npm run build",
+    "dev": "concurrently --names build,sandbox \"rollup -c -w --environment SANDBOX\" \"cd sandbox && export REACT_APP_NONCE=321 && npm start\"",
+    "dev:standalone": "npm run clean && rollup -c -w --environment STANDALONE",
+    "build": "npm run clean && rollup -c --environment BASE_CODE_MIN,STANDALONE,STANDALONE_MIN,BUNDLESIZE && echo \"Base Code:\" && cat distTest/baseCode.min.js",
+    "build:watch": "npm run clean && rollup -c --watch --environment BASE_CODE_MIN,STANDALONE",
     "build:custom": "node scripts/alloyBuilder.js",
     "prepare": "husky && cd sandbox && npm install",
-    "prepack": "npm run clean && npm run build",
+    "prepack": "npm run clean && babel src -d libEs5 --env-name npmEs5 && babel src -d libEs6 --env-name npmEs6 && npm run types",
     "checkthattestfilesexist": "./scripts/checkThatTestFilesExist.js",
     "add-license": "./scripts/add-license.js"
   },
@@ -86,8 +84,8 @@
     "@babel/plugin-transform-template-literals": "^7.27.1",
     "@babel/preset-env": "^7.27.2",
     "@inquirer/prompts": "^7.5.3",
+    "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^28.0.3",
-    "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-terser": "^0.4.4",
     "commander": "^14.0.0",
@@ -98,15 +96,14 @@
     "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@adobe/alloy": "^2.28.0-beta.7",
+    "@adobe/alloy": "^2.28.0",
     "@babel/cli": "^7.27.2",
+    "@babel/plugin-transform-modules-commonjs": "^7.27.1",
     "@babel/plugin-transform-runtime": "^7.27.4",
     "@eslint/js": "^9.28.0",
     "@octokit/rest": "^22.0.0",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-typescript": "^12.1.2",
-    "@vitest/browser": "^3.2.0",
-    "@vitest/coverage-v8": "^3.2.0",
+    "@vitest/browser": "^3.1.4",
+    "@vitest/coverage-v8": "^3.1.4",
     "@vitest/eslint-plugin": "^1.2.1",
     "chalk": "^5.4.1",
     "date-fns": "^4.1.0",
@@ -135,7 +132,6 @@
     "testcafe-browser-provider-saucelabs": "^3.0.0",
     "testcafe-reporter-junit": "^3.0.2",
     "testcafe-reporter-saucelabs": "^3.6.0",
-    "tslib": "^2.8.1",
     "typescript": "^5.8.3",
     "url-exists-nodejs": "^0.2.4",
     "url-parse": "^1.5.10",