expo-native-variants 0.0.0 → 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christoph Pader
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+# expo-native-variants
+
+Generate every native app variant in one Expo prebuild. Switch between development, preview, and production in Xcode or Android Studio while keeping `ios/` and `android/` generated and ignored by Git.
+
+The npm version `0.0.0` contains only a package-name reservation. Build from this repository until the first implementation release is published.
+
+This community-maintained package targets Expo SDK 57. It is an early release for the standard Expo native templates with one iOS application target and one Android flavor dimension. See [compatibility](#compatibility) before adding it to an existing app.
+
+See the [validation record](./VALIDATION.md) for tested toolchain versions and results.
+
+## Configure variants
+
+Install `expo-native-variants` in your Expo project and add it to the `plugins` array in your app config. Use complete application identifiers so the variants can be installed together.
+
+```json
+{
+  "expo": {
+    "name": "Acme",
+    "slug": "acme",
+    "ios": { "bundleIdentifier": "com.acme.app" },
+    "android": { "package": "com.acme.app" },
+    "plugins": [
+      [
+        "expo-native-variants",
+        {
+          "defaultVariant": "production",
+          "variants": {
+            "development": {
+              "displayName": "Acme Dev",
+              "applicationId": "com.acme.app.dev",
+              "urlScheme": "acme-dev",
+              "runMode": "debug"
+            },
+            "preview": {
+              "displayName": "Acme Preview",
+              "applicationId": "com.acme.app.preview",
+              "urlScheme": "acme-preview",
+              "runMode": "release"
+            },
+            "production": {
+              "displayName": "Acme",
+              "applicationId": "com.acme.app",
+              "urlScheme": "acme",
+              "runMode": "release"
+            }
+          }
+        }
+      ]
+    ]
+  }
+}
+```
+
+Run Expo prebuild, then open the generated native projects. Native dependencies and configuration changes require another prebuild. Selecting an existing variant does not.
+
+```sh
+expo prebuild --clean
+```
+
+| Variant | Xcode scheme | Xcode configurations | Android variants |
+| --- | --- | --- | --- |
+| development | `Acme-Development` | `Debug-Development`, `Release-Development` | `developmentDebug`, `developmentRelease` |
+| preview | `Acme-Preview` | `Debug-Preview`, `Release-Preview` | `previewDebug`, `previewRelease` |
+| production | `Acme-Production` | `Debug-Production`, `Release-Production` | `productionDebug`, `productionRelease` |
+
+Choose a scheme in the iOS workspace or a build variant in Android Studio. Every variant supports debug and release builds. A debug build and a release build of the same variant share an identifier, so installing one replaces the other.
+
+For Android, Expo CLI also accepts explicit variant and application selection:
+
+```sh
+expo run:android --variant developmentDebug --app-id com.acme.app.dev
+```
+
+On iOS, use Xcode for custom configurations. Expo CLI 57 defaults to the ordinary `Debug` configuration unless one is specified, and its environment-mode handling checks for the literal name `Release`. Selecting a custom scheme alone does not reliably select its configured build mode.
+
+## Options
+
+`defaultVariant` names the variant used by the ordinary iOS `Debug` and `Release` configurations and the canonical app identity. The base `ios.bundleIdentifier` and `android.package` must match it when supplied. Every variant is generated regardless of the default.
+
+| Variant option | Purpose |
+| --- | --- |
+| `displayName` | Name shown under the app icon |
+| `applicationId` | Full identifier shared by iOS and Android |
+| `urlScheme` | Custom URL scheme owned by this variant |
+| `runMode` | Xcode Run action's mode, `debug` by default |
+| `ios.bundleIdentifier` | Optional replacement for the shared identifier on iOS |
+| `ios.xcodeScheme` | Optional Xcode build-scheme name |
+| `android.applicationId` | Optional replacement for the shared identifier on Android |
+
+Variant keys determine the Android flavor names and generated iOS configuration names. Identifiers must be unique on each platform. The plugin rejects invalid names and collisions before generating native settings.
+
+The plugin changes the display name while keeping the native target, product name, and Android source namespace stable. It owns its generated files and configuration sections. Repeated prebuilds update them, including renamed or removed variants. If you remove the plugin itself, perform a clean prebuild to remove its native output.
+
+## Read the installed variant
+
+Install `expo-application` if your app needs runtime variant selection. Keep the variant map in a shared module and pass the installed identifier to the separate runtime entry point:
+
+```ts
+import * as Application from 'expo-application';
+import { getNativeVariant } from 'expo-native-variants/runtime';
+
+import { variants } from './variants';
+
+const variant = getNativeVariant(Application.applicationId, variants);
+```
+
+The helper returns the variant key or `null` when the identifier is missing, unknown, or ambiguous. It never assumes production for Expo Go or web. Pass a third argument, `'ios'` or `'android'`, if your map reuses the same identifier for different variants across platforms.
+
+The runtime helper contains no config-plugin code and requires no native module of its own. The installed application's identifier remains the source of identity when JavaScript is reloaded or updated. A scheme change does not change bundled `EXPO_PUBLIC_*` variables or Expo's shared `extra` values.
+
+## Development clients and links
+
+Each variant gets its own custom URL scheme. If using `expo-dev-client`, configure its `addGeneratedScheme` option as `false` to avoid the shared default development-client scheme. The variant's custom scheme can open its development client.
+
+```json
+["expo-dev-client", { "addGeneratedScheme": false }]
+```
+
+Keep this entry before `expo-native-variants` in the plugins array. Existing third-party URL registrations are not automatically rewritten for separate OAuth applications. Configure those services explicitly and check their callbacks with every installed variant.
+
+Start Metro with the selected variant's explicit scheme. Expo CLI's Android scheme discovery reads the unexpanded manifest placeholders, so its automatically generated launch URL may contain a placeholder.
+
+```sh
+expo start --dev-client --scheme acme-dev
+```
+
+The Android development launcher also registers its own fixed `expo-dev-launcher` authentication scheme. That upstream callback remains shared when several debug clients are installed. The plugin preserves it and emits a warning. Use each variant's configured URL scheme for application links and development-client launch URLs.
+
+## Experimental EAS configuration
+
+EAS reads application identifiers before native generation. The optional config helper projects a selected variant's identifiers into app config and keeps the same selection for the canonical native configurations. It still generates every variant.
+
+```ts
+import { createNativeVariantsConfig } from 'expo-native-variants/config';
+
+import { options } from './variants';
+
+export default () => createNativeVariantsConfig({
+  config: { name: 'Acme', slug: 'acme' },
+  options,
+  variant: process.env.NATIVE_VARIANT,
+});
+```
+
+Declare `NATIVE_VARIANT` explicitly in each EAS profile's `env` object. Local development can leave it unset and switch between generated native variants as usual. The helper uses `variant`, then `options.canonicalVariant`, then `defaultVariant`. It preserves the app name and existing plugins, registers this plugin last, and rejects duplicate registration. It does not read environment variables itself.
+
+The [example profiles](./example/eas.json) select Android Gradle tasks and ordinary iOS Debug/Release configurations. Treat them as a starting point. Cloud builds, signing, provisioning, and credential selection have not been verified, so the helper is experimental. Do not rely on the cloud-only `EAS_BUILD_PROFILE` variable for local credential preflight.
+
+## Compatibility
+
+The first release supports Expo's generated Android Groovy template and a single iOS application target. Existing Android product flavors, additional flavor dimensions, Kotlin DSL projects, iOS extensions, and existing native test targets are outside its supported layout.
+
+Expo SDK 57's default iOS template does not enable scene lifecycle support. A build linked with the iOS 27 SDK can crash on iOS 27 before JavaScript starts. Use Expo's [official scene-support configuration](https://github.com/expo/fyi/blob/main/ios-scene-lifecycle.md) when targeting that combination. The example's launch tests use iOS 26.5.
+
+The native dependency graph remains shared. Arbitrary per-variant Expo config objects, different plugin lists, icons, Firebase service files, entitlements, and update channels are not supported options. Other plugins can still modify native settings, so validate integrations that touch the same files.
+
+Remote update routing is not isolated by application identifiers alone. Configure and test update channels and runtime compatibility separately. The example disables remote updates.
+
+EAS support remains experimental until its credential preflight and cloud artifacts have been verified. Managed EAS builds resolve app identifiers before native generation and do not select arbitrary generated iOS schemes in the same way as Xcode. Local native generation does not establish EAS compatibility.
+
+## Example and development
+
+The [example](./example) contains three variants and displays the installed identifier, resolved variant, and debug/release mode. Install the repository dependencies, build the package, generate the example's native projects, and open its iOS workspace or Android project.
+
+The root package scripts provide `build`, `typecheck`, `test`, `test:integration`, and `verify:package`. After generating the example and installing native dependencies, `build:native:android` and `build:native:ios` build every debug/release combination without another prebuild. Native build validation requires Xcode with CocoaPods on macOS, or an Android SDK and compatible Java installation. Keep the example's generated native folders out of commits.
+
+## License
+
+[MIT](./LICENSE).

package/app.plugin.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./dist/index.js').default;

package/dist/config/index.d.mts

@@ -0,0 +1,22 @@
+import { ExpoConfig } from 'expo/config';
+import { N as NativeVariantsOptions, a as NativeVariantOptions } from '../types-BEqszr6O.mjs';
+
+type CreateNativeVariantsConfigArgs = Readonly<{
+    config: ExpoConfig;
+    options: NativeVariantsConfigInput;
+    variant?: string;
+}>;
+type NativeVariantConfigInput = Readonly<Omit<NativeVariantOptions, 'runMode'> & {
+    runMode?: string;
+}>;
+type NativeVariantsConfigInput = Readonly<Omit<NativeVariantsOptions, 'variants'> & {
+    variants: Readonly<Record<string, NativeVariantConfigInput>>;
+}>;
+/**
+ * Projects one variant's identifiers into app config before EAS reads them,
+ * while registering the plugin with the complete native variant matrix.
+ * This helper remains experimental until cloud builds are verified.
+ */
+declare function createNativeVariantsConfig({ config, options, variant, }: CreateNativeVariantsConfigArgs): ExpoConfig;
+
+export { type CreateNativeVariantsConfigArgs, type NativeVariantsConfigInput, createNativeVariantsConfig };

package/dist/config/index.d.ts

@@ -0,0 +1,22 @@
+import { ExpoConfig } from 'expo/config';
+import { N as NativeVariantsOptions, a as NativeVariantOptions } from '../types-BEqszr6O.js';
+
+type CreateNativeVariantsConfigArgs = Readonly<{
+    config: ExpoConfig;
+    options: NativeVariantsConfigInput;
+    variant?: string;
+}>;
+type NativeVariantConfigInput = Readonly<Omit<NativeVariantOptions, 'runMode'> & {
+    runMode?: string;
+}>;
+type NativeVariantsConfigInput = Readonly<Omit<NativeVariantsOptions, 'variants'> & {
+    variants: Readonly<Record<string, NativeVariantConfigInput>>;
+}>;
+/**
+ * Projects one variant's identifiers into app config before EAS reads them,
+ * while registering the plugin with the complete native variant matrix.
+ * This helper remains experimental until cloud builds are verified.
+ */
+declare function createNativeVariantsConfig({ config, options, variant, }: CreateNativeVariantsConfigArgs): ExpoConfig;
+
+export { type CreateNativeVariantsConfigArgs, type NativeVariantsConfigInput, createNativeVariantsConfig };

package/dist/config/index.js

@@ -0,0 +1,397 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  createNativeVariantsConfig: () => createNativeVariantsConfig
+});
+module.exports = __toCommonJS(config_exports);
+
+// src/options/normalize.ts
+var ROOT_KEYS = /* @__PURE__ */ new Set(["canonicalVariant", "defaultVariant", "variants"]);
+var VARIANT_KEYS = /* @__PURE__ */ new Set([
+  "android",
+  "applicationId",
+  "displayName",
+  "ios",
+  "runMode",
+  "urlScheme"
+]);
+var IOS_KEYS = /* @__PURE__ */ new Set(["bundleIdentifier", "xcodeScheme"]);
+var ANDROID_KEYS = /* @__PURE__ */ new Set(["applicationId"]);
+var RESERVED_VARIANT_NAMES = /* @__PURE__ */ new Set([
+  "androidtest",
+  "aux",
+  "con",
+  "debug",
+  "main",
+  "nul",
+  "prn",
+  "release",
+  "test",
+  "unittest"
+]);
+var WINDOWS_DEVICE_NAME = /^(?:com|lpt)[0-9]$/i;
+var VARIANT_KEY = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var SAFE_FILE_LABEL = /^[A-Za-z0-9][A-Za-z0-9 ._-]*$/;
+var URL_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/;
+var IOS_IDENTIFIER_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
+var ANDROID_IDENTIFIER_SEGMENT = /^[A-Za-z][A-Za-z0-9_]*$/;
+function normalizeNativeVariants({
+  configName,
+  options,
+  canonicalVariant: canonicalOverride
+}) {
+  validateFileLabel(configName, "Expo config name");
+  const optionsRecord = requireRecord(options, "Plugin options");
+  assertKnownKeys(optionsRecord, ROOT_KEYS, "Plugin options");
+  const defaultVariant = requireNonemptyString(
+    optionsRecord.defaultVariant,
+    "defaultVariant"
+  );
+  const configuredCanonicalVariant = optionalNonemptyString(
+    optionsRecord.canonicalVariant,
+    "canonicalVariant"
+  );
+  const canonicalVariant = canonicalOverride ?? configuredCanonicalVariant ?? defaultVariant;
+  validateVariantKey(defaultVariant, "defaultVariant");
+  validateVariantKey(canonicalVariant, "canonicalVariant");
+  const variantsRecord = requireRecord(optionsRecord.variants, "variants");
+  const variantEntries = Object.entries(variantsRecord);
+  if (variantEntries.length === 0) {
+    throw new Error("variants must contain at least one variant.");
+  }
+  const normalizedVariants = variantEntries.map(
+    ([key, variant]) => normalizeVariant({ configName, key, variant })
+  );
+  validateGeneratedNames(normalizedVariants);
+  validateUniqueValues(normalizedVariants);
+  if (!Object.hasOwn(variantsRecord, defaultVariant)) {
+    throw new Error(`defaultVariant references unknown variant "${defaultVariant}".`);
+  }
+  const canonical = normalizedVariants.find(({ key }) => key === canonicalVariant);
+  if (canonical === void 0) {
+    throw new Error(`canonicalVariant references unknown variant "${canonicalVariant}".`);
+  }
+  const variants = Object.freeze(normalizedVariants);
+  return Object.freeze({ canonicalVariant: canonical, variants });
+}
+function normalizeVariant({
+  configName,
+  key,
+  variant
+}) {
+  validateVariantKey(key, `Variant key "${key}"`);
+  const variantRecord = requireRecord(variant, `Variant "${key}"`);
+  assertKnownKeys(variantRecord, VARIANT_KEYS, `Variant "${key}"`);
+  const displayName = requireNonemptyString(
+    variantRecord.displayName,
+    `Variant "${key}" displayName`
+  );
+  validateText(displayName, `Variant "${key}" displayName`);
+  const applicationId = requireNonemptyString(
+    variantRecord.applicationId,
+    `Variant "${key}" applicationId`
+  );
+  const urlScheme = requireNonemptyString(
+    variantRecord.urlScheme,
+    `Variant "${key}" urlScheme`
+  );
+  validateUrlScheme(urlScheme, `Variant "${key}" urlScheme`);
+  const runMode = readRunMode(variantRecord.runMode, key);
+  const ios = readIosOptions(variantRecord.ios, key);
+  const android = readAndroidOptions(variantRecord.android, key);
+  const iosBundleIdentifier = ios.bundleIdentifier ?? applicationId;
+  const androidApplicationId = android.applicationId ?? applicationId;
+  validateIosIdentifier(iosBundleIdentifier, `Variant "${key}" iOS bundle identifier`);
+  validateAndroidIdentifier(
+    androidApplicationId,
+    `Variant "${key}" Android application ID`
+  );
+  const configLabel = toPascalConfigLabel(key);
+  const generatedIosScheme = `${configName}-${configLabel}`;
+  const iosScheme = ios.xcodeScheme ?? generatedIosScheme;
+  validateFileLabel(iosScheme, `Variant "${key}" iOS scheme`);
+  return Object.freeze({
+    key,
+    displayName,
+    iosBundleIdentifier,
+    androidApplicationId,
+    urlScheme,
+    runMode,
+    iosScheme,
+    debugConfiguration: `Debug-${configLabel}`,
+    releaseConfiguration: `Release-${configLabel}`,
+    androidFlavor: lowerFirst(configLabel)
+  });
+}
+function readIosOptions(value, variantKey) {
+  if (value === void 0) {
+    return {};
+  }
+  const record = requireRecord(value, `Variant "${variantKey}" ios`);
+  assertKnownKeys(record, IOS_KEYS, `Variant "${variantKey}" ios`);
+  const bundleIdentifier = optionalNonemptyString(
+    record.bundleIdentifier,
+    `Variant "${variantKey}" ios.bundleIdentifier`
+  );
+  const xcodeScheme = optionalNonemptyString(
+    record.xcodeScheme,
+    `Variant "${variantKey}" ios.xcodeScheme`
+  );
+  return compactOptionalStrings({ bundleIdentifier, xcodeScheme });
+}
+function readAndroidOptions(value, variantKey) {
+  if (value === void 0) {
+    return {};
+  }
+  const record = requireRecord(value, `Variant "${variantKey}" android`);
+  assertKnownKeys(record, ANDROID_KEYS, `Variant "${variantKey}" android`);
+  const applicationId = optionalNonemptyString(
+    record.applicationId,
+    `Variant "${variantKey}" android.applicationId`
+  );
+  return applicationId === void 0 ? {} : { applicationId };
+}
+function compactOptionalStrings({
+  bundleIdentifier,
+  xcodeScheme
+}) {
+  if (bundleIdentifier === void 0) {
+    if (xcodeScheme === void 0) {
+      return {};
+    }
+    return { xcodeScheme };
+  }
+  if (xcodeScheme === void 0) {
+    return { bundleIdentifier };
+  }
+  return { bundleIdentifier, xcodeScheme };
+}
+function readRunMode(value, variantKey) {
+  if (value === void 0) {
+    return "debug";
+  }
+  if (value === "debug" || value === "release") {
+    return value;
+  }
+  throw new Error(`Variant "${variantKey}" runMode must be "debug" or "release".`);
+}
+function validateGeneratedNames(variants) {
+  for (const variant of variants) {
+    const generatedName = variant.androidFlavor.toLowerCase();
+    if (RESERVED_VARIANT_NAMES.has(generatedName) || WINDOWS_DEVICE_NAME.test(generatedName)) {
+      throw new Error(
+        `Variant key "${variant.key}" produces reserved name "${variant.androidFlavor}".`
+      );
+    }
+  }
+  assertUnique(variants, ({ key }) => key.toLowerCase(), "variant key");
+  assertUnique(variants, ({ debugConfiguration }) => debugConfiguration.toLowerCase(), "iOS configuration");
+  assertUnique(variants, ({ iosScheme }) => iosScheme.toLowerCase(), "iOS scheme");
+  assertUnique(variants, ({ androidFlavor }) => androidFlavor.toLowerCase(), "Android flavor");
+}
+function validateUniqueValues(variants) {
+  assertUnique(
+    variants,
+    ({ iosBundleIdentifier }) => iosBundleIdentifier.toLowerCase(),
+    "iOS bundle identifier"
+  );
+  assertUnique(
+    variants,
+    ({ androidApplicationId }) => androidApplicationId.toLowerCase(),
+    "Android application ID"
+  );
+  assertUnique(variants, ({ urlScheme }) => urlScheme.toLowerCase(), "URL scheme");
+  assertNoCrossVariantRouteCollision({
+    identifierLabel: "iOS bundle identifier",
+    selectIdentifier: ({ iosBundleIdentifier }) => iosBundleIdentifier,
+    variants
+  });
+  assertNoCrossVariantRouteCollision({
+    identifierLabel: "Android application ID",
+    selectIdentifier: ({ androidApplicationId }) => androidApplicationId,
+    variants
+  });
+}
+function assertNoCrossVariantRouteCollision({
+  identifierLabel,
+  selectIdentifier,
+  variants
+}) {
+  const identifierOwnerByValue = new Map(
+    variants.map((variant) => [
+      selectIdentifier(variant).toLowerCase(),
+      variant.key
+    ])
+  );
+  for (const variant of variants) {
+    const identifierOwner = identifierOwnerByValue.get(variant.urlScheme.toLowerCase());
+    if (identifierOwner !== void 0 && identifierOwner !== variant.key) {
+      throw new Error(
+        `Variant "${variant.key}" URL scheme "${variant.urlScheme}" matches variant "${identifierOwner}" ${identifierLabel}.`
+      );
+    }
+  }
+}
+function assertUnique(variants, select, label) {
+  const ownerByValue = /* @__PURE__ */ new Map();
+  for (const variant of variants) {
+    const value = select(variant);
+    const owner = ownerByValue.get(value);
+    if (owner !== void 0) {
+      throw new Error(
+        `Variants "${owner}" and "${variant.key}" produce the same ${label} "${value}".`
+      );
+    }
+    ownerByValue.set(value, variant.key);
+  }
+}
+function validateVariantKey(value, label) {
+  if (!VARIANT_KEY.test(value)) {
+    throw new Error(
+      `${label} must start with a letter and contain only letters, numbers, hyphens, or underscores.`
+    );
+  }
+  const normalized = value.toLowerCase();
+  if (RESERVED_VARIANT_NAMES.has(normalized) || WINDOWS_DEVICE_NAME.test(normalized)) {
+    throw new Error(`${label} uses reserved name "${value}".`);
+  }
+}
+function validateFileLabel(value, label) {
+  if (value !== value.trim() || !SAFE_FILE_LABEL.test(value) || value === "." || value === "..") {
+    throw new Error(
+      `${label} must be a path-safe name containing only letters, numbers, spaces, periods, hyphens, or underscores.`
+    );
+  }
+}
+function validateText(value, label) {
+  if (new RegExp("\\p{Cc}", "u").test(value)) {
+    throw new Error(`${label} must not contain control characters.`);
+  }
+}
+function validateUrlScheme(value, label) {
+  if (!URL_SCHEME.test(value)) {
+    throw new Error(
+      `${label} must start with a letter and contain only letters, numbers, plus signs, periods, or hyphens.`
+    );
+  }
+}
+function validateIosIdentifier(value, label) {
+  const segments = value.split(".");
+  if (segments.length < 2 || segments.some((segment) => !IOS_IDENTIFIER_SEGMENT.test(segment))) {
+    throw new Error(`${label} must be a valid reverse-DNS bundle identifier.`);
+  }
+}
+function validateAndroidIdentifier(value, label) {
+  const segments = value.split(".");
+  if (segments.length < 2 || segments.some((segment) => !ANDROID_IDENTIFIER_SEGMENT.test(segment))) {
+    throw new Error(`${label} must be a valid reverse-DNS application ID.`);
+  }
+}
+function toPascalConfigLabel(value) {
+  const words = value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").split(/[-_]+/).filter((word) => word.length > 0);
+  return words.map(capitalize).join("");
+}
+function capitalize(value) {
+  return `${value[0]?.toUpperCase() ?? ""}${value.slice(1).toLowerCase()}`;
+}
+function lowerFirst(value) {
+  return `${value[0]?.toLowerCase() ?? ""}${value.slice(1)}`;
+}
+function requireNonemptyString(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${label} must be a nonempty string.`);
+  }
+  return value;
+}
+function optionalNonemptyString(value, label) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return requireNonemptyString(value, label);
+}
+function requireRecord(value, label) {
+  if (!isRecord(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertKnownKeys(record, knownKeys, label) {
+  const unknownKey = Object.keys(record).find((key) => !knownKeys.has(key));
+  if (unknownKey !== void 0) {
+    throw new Error(`${label} contains unknown key "${unknownKey}".`);
+  }
+}
+
+// src/config/index.ts
+var PLUGIN_NAME = "expo-native-variants";
+var PLUGIN_SPECIFIERS = /* @__PURE__ */ new Set([
+  PLUGIN_NAME,
+  `${PLUGIN_NAME}/app.plugin.js`
+]);
+function createNativeVariantsConfig({
+  config,
+  options,
+  variant
+}) {
+  assertPluginIsNotRegistered(config.plugins);
+  const canonicalVariant = variant ?? options.canonicalVariant ?? options.defaultVariant;
+  const normalized = normalizeNativeVariants({
+    canonicalVariant,
+    configName: config.name,
+    options
+  });
+  const selected = normalized.canonicalVariant;
+  const pluginOptions = {
+    ...options,
+    canonicalVariant: selected.key
+  };
+  return {
+    ...config,
+    android: {
+      ...config.android,
+      package: selected.androidApplicationId
+    },
+    ios: {
+      ...config.ios,
+      bundleIdentifier: selected.iosBundleIdentifier
+    },
+    plugins: [...config.plugins ?? [], [PLUGIN_NAME, pluginOptions]]
+  };
+}
+function assertPluginIsNotRegistered(plugins) {
+  const existingRegistration = plugins?.find(
+    (plugin) => typeof plugin === "string" && PLUGIN_SPECIFIERS.has(plugin) || Array.isArray(plugin) && PLUGIN_SPECIFIERS.has(plugin[0] ?? "")
+  );
+  if (existingRegistration !== void 0) {
+    throw new Error(
+      "expo-native-variants is already registered in config.plugins. Remove the existing entry before using createNativeVariantsConfig."
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNativeVariantsConfig
+});
+//# sourceMappingURL=index.js.map