@worldcoin/nucleus 0.1.4

package/README.md

@@ -0,0 +1,281 @@
+# Nucleus
+
+A cross-platform design system for the World ecosystem. Nucleus publishes design tokens (colors, typography) and a small set of components as platform-native packages for Android, iOS, and web.
+
+- [Architecture](#architecture)
+- [Quick start](#quick-start)
+- [Token reference](#token-reference)
+  - [Color tokens](#color-tokens)
+  - [Typography tokens](#typography-tokens)
+- [Consuming Nucleus](#consuming-nucleus)
+- [Adding or modifying tokens](#adding-or-modifying-tokens)
+- [Releases](#releases)
+
+## Architecture
+
+Tokens are authored as JSON in `tokens/definitions/`. A TypeScript build pipeline reads the JSON through a validating loader, runs format-specific generators, and writes platform-native source files into the repo. The generated files are committed; CI verifies they are in sync with the source JSON on every PR.
+
+```mermaid
+graph TD
+    A[tokens/definitions/*.json] --> B[loaders<br/>tokens/formats/loaders.ts]
+    B --> C[per-platform format functions<br/>tokens/formats/*-android, *-ios, *-web]
+    C -->|Handlebars templates| D[android/nucleus/src/main]
+    C -->|Handlebars templates| E[ios/Sources]
+    C -->|strings + asset copy| F[build/web]
+```
+
+**Design principles**
+
+- **JSON is the single source of truth.** Every platform output is derived from the same JSON; nothing is hand-edited downstream.
+- **Source layers are explicit in token paths.** Color tokens live under `primitive.color.*` and `semantic.color.*`. Font tokens are split into a `families` block (font files) and a `tokens` block (typography styles).
+- **Platform outputs are standalone.** No app-specific dependencies. Android gets Compose `Color` / `NucleusFontStyle` values; iOS gets a `NucleusColor` struct and a `NucleusFont` struct; web gets CSS custom properties + JSON.
+- **Generated files are committed.** CI runs `npm run build` then `git diff --exit-code` to ensure the source and generated outputs stay in sync.
+
+## Quick start
+
+```bash
+npm ci
+npm run build
+```
+
+Generated files appear in:
+
+| Platform | Path                                                | Contents                                                                |
+| -------- | --------------------------------------------------- | ----------------------------------------------------------------------- |
+| Android  | `android/nucleus/src/main/java/com/worldcoin/nucleus/tokens/` | Kotlin objects (`NucleusPrimitiveColors`, `NucleusSemanticColorsLight`/`Dark`, `NucleusFonts`) shipped in the `android/nucleus` Maven artifact |
+| Android  | `android/nucleus/src/main/res/font/`                | Bundled font files (`.ttf`)                                             |
+| iOS      | `ios/Sources/NucleusColors/`                        | `NucleusColor` struct + generated `NucleusColor+Primitives.swift` and `NucleusColor+Semantics.swift` (SPM library `NucleusColors`) |
+| iOS      | `ios/Sources/NucleusFonts/`                         | `NucleusFont` struct + generated `NucleusFont+Defaults.swift` and bundled font resources (SPM library `NucleusFonts`) |
+| Web      | `build/web/`                                        | CSS custom properties (`nucleus-*.css`), JSON token files, font files, `package.json` for npm publishing |
+
+The repo-root `VERSION` file is the canonical version. `npm run build` stamps it into the web `package.json`; the Android library reads it from `build.gradle.kts`; SPM consumes the SPM tag.
+
+## Token reference
+
+### Color tokens
+
+Colors are layered:
+
+- **Primitive** (`primitive.color.*`) — raw palette values (e.g. `grey.500`, `red.700`). Use only when no semantic token fits.
+- **Semantic** (`semantic.color.*`) — purpose-named tokens that adapt to theme (e.g. `surface.primary`, `text.primary`). Prefer these in product code so light/dark swap automatically.
+
+Source: `tokens/definitions/color/primitive.json`, `tokens/definitions/color/semantic.light.json`, `tokens/definitions/color/semantic.dark.json`.
+
+### Typography tokens
+
+Source: `tokens/definitions/font/fonts.json`.
+
+Typography is organized into six **categories**, each with one or more sizes (1 = largest within the category).
+
+| Category | Prefix | Sizes used today | Intended use                                                                             |
+| -------- | ------ | ---------------- | ---------------------------------------------------------------------------------------- |
+| Display  | `d`    | `d1`             | Hero / marketing-scale text.                                                             |
+| Numeric  | `n`    | `n1`–`n5`        | Large numeric readouts (balances, scores, counters) — semibold weight, tighter tracking. |
+| Heading  | `h`    | `h1`–`h4`        | Section and view titles. Decreasing prominence from `h1` to `h4`.                        |
+| Subtitle | `s`    | `s1`–`s4`        | Secondary headings or emphasized labels. Medium weight.                                  |
+| Label    | `l`    | `l1`–`l3`        | Buttons, chips, captions, badge text. Semibold weight.                                   |
+| Body     | `b`    | `b1`–`b4`        | Paragraph and content text. Lighter weight (325), looser line height (1.3).              |
+
+**Picking a token.** Start from the *category* (what role does this text play?), then choose the *size* that matches the visual hierarchy of the screen. Don't mix categories at the same hierarchy level on one screen.
+
+Each token carries: `family` (font file), `size` (pt / sp / px), `weight` (variable axis value, typically 300–800), `letterSpacing` (em multiplier), `lineHeight` (em multiplier), and an optional `dynamicTypeStyle` for iOS Dynamic Type scaling.
+
+> TODO: the category names (Display, Numeric, Heading, etc.) are inferred from prefix conventions; double check with design on canonical names.
+
+## Consuming Nucleus
+
+<details>
+<summary><b>Android</b></summary>
+
+Add the GitHub Packages Maven repository to `settings.gradle.kts`:
+
+```kotlin
+maven {
+    url = uri("https://maven.pkg.github.com/worldcoin/nucleus")
+    credentials {
+        username = System.getenv("GITHUB_USER")
+        password = System.getenv("GITHUB_TOKEN")
+    }
+}
+```
+
+Then add the dependency:
+
+```kotlin
+implementation("com.worldcoin:nucleus:<version>")
+```
+
+**Colors**
+
+```kotlin
+import com.worldcoin.nucleus.tokens.NucleusPrimitiveColors
+import com.worldcoin.nucleus.tokens.NucleusSemanticColorsLight
+
+val grey = NucleusPrimitiveColors.grey900
+val surface = NucleusSemanticColorsLight.surfacePrimary
+```
+
+**Typography**
+
+```kotlin
+import androidx.compose.material3.Text
+import androidx.compose.ui.text.TextStyle
+import com.worldcoin.nucleus.tokens.NucleusFonts
+
+val style = with(NucleusFonts.b1) {
+    TextStyle(
+        fontFamily = fontFamily,
+        fontSize = fontSize,
+        fontWeight = fontWeight,
+        letterSpacing = letterSpacing,
+        lineHeight = lineHeight,
+    )
+}
+
+Text("Hello", style = style)
+```
+
+`NucleusFonts.<token>.fontFamily` is wired to the bundled font resource — no `R.font.*` lookup needed.
+
+</details>
+
+<details>
+<summary><b>iOS</b></summary>
+
+Add the SPM dependency in your `Package.swift`:
+
+```swift
+.package(url: "https://github.com/worldcoin/nucleus.git", branch: "generated/ios")
+```
+
+Or pin to a specific release tag (e.g. `vX.Y.Z-ios`). Then add the libraries you need as target dependencies:
+
+```swift
+.target(
+    name: "YourTarget",
+    dependencies: [
+        .product(name: "NucleusColors", package: "nucleus"),
+        .product(name: "NucleusFonts", package: "nucleus"),
+    ]
+)
+```
+
+**Colors**
+
+```swift
+import NucleusColors
+import SwiftUI
+
+Text("Hello")
+    .foregroundStyle(NucleusColor.surfacePrimary.color) // adapts to light/dark
+    .background(NucleusColor.grey900.color)             // primitive
+```
+
+**Typography**
+
+```swift
+import NucleusFonts
+import SwiftUI
+
+// Register bundled fonts once at app launch.
+NucleusFont.registerFonts()
+
+Text("Hello")
+    .font(NucleusFont.b1.asFont())
+```
+
+`NucleusFont` supports variable weight axis, monospaced digits, and Dynamic Type. See `ios/Sources/NucleusFonts/NucleusFont.swift` for the full API.
+
+</details>
+
+<details>
+<summary><b>Web</b></summary>
+
+Install from npm (public, no auth required):
+
+```bash
+npm install @worldcoin/nucleus
+```
+
+**Colors**
+
+```css
+@import "@worldcoin/nucleus/nucleus-primitive-colors.css";
+@import "@worldcoin/nucleus/nucleus-semantic-colors-light.css";
+
+.card {
+  color: var(--nucleus-text-primary);
+  background: var(--nucleus-surface-primary);
+  border: 1px solid var(--nucleus-grey-200);
+}
+```
+
+**Typography**
+
+```css
+@import "@worldcoin/nucleus/nucleus-fonts.css";
+
+@font-face {
+  font-family: "WorldProMVPLH-Regular";
+  src: url("@worldcoin/nucleus/fonts/WorldProMVP.ttf") format("truetype");
+}
+
+.headline {
+  font-family: var(--nucleus-font-h1-family);
+  font-size: var(--nucleus-font-h1-size);
+  font-weight: var(--nucleus-font-h1-weight);
+  letter-spacing: var(--nucleus-font-h1-letter-spacing);
+  line-height: var(--nucleus-font-h1-line-height);
+}
+```
+
+**JSON tokens (for JS/TS)**
+
+```ts
+import colors from "@worldcoin/nucleus/nucleus-primitive-colors.json";
+import fonts from "@worldcoin/nucleus/nucleus-fonts.json";
+```
+
+</details>
+
+## Adding or modifying tokens
+
+1. Edit the relevant JSON file in `tokens/definitions/`. The loader validates the shape at build time and throws a clear error if a field is missing or malformed.
+2. Run `npm run build` to regenerate platform sources and verify output.
+3. Commit both the source change *and* the regenerated files (CI enforces this with `git diff --exit-code`).
+4. Open a PR with a release label (`patch`, `minor`, or `major`).
+
+For new typography tokens: add the font file to `tokens/definitions/font/`, declare it in the `families` block of `fonts.json`, then reference it from the token. The Android resource name is derived by snake-casing the filename.
+
+## Releases
+
+Release automation is split across two workflows:
+
+- `.github/workflows/prepare-release.yml` — prepares release PRs
+- `.github/workflows/publish-release.yml` — tags and publishes merged release PRs
+
+The prepare workflow runs in two modes:
+
+- **Push to `main`** after merging a PR with a release label (`major`, `minor`, `patch`) — the workflow derives the bump from the merged PR, creates a `release/v*` branch, and opens a release PR.
+- **Manual dispatch** — choose the bump type from the Actions UI to create the same release PR flow without a source PR label.
+
+If the computed tag already exists, `prepare-release.yml` skips instead of opening a duplicate.
+
+### Pipeline steps
+
+1. **Release PR creation** — `prepare-release.yml` determines the next version, updates `VERSION`, `package.json`, `package-lock.json`, and `CHANGELOG.md`, then opens a `release/v*` PR.
+2. **Release PR merge** — merging that PR back into `main` triggers `publish-release.yml`.
+3. **Tag + build** — the merged release commit is tagged as `v*`, then `npm run build` runs and uploads `android-tokens`, `ios-tokens`, and `web-tokens`.
+4. **publish-mvn** — publishes Android library to GitHub Packages.
+5. **publish-spm** — commits generated iOS files to the `generated/ios` branch, tags as `v*-ios`.
+6. **publish-npm** / **publish-gh-packages** — two independent jobs publish the web package (`@worldcoin/nucleus`): the primary to the **public npm registry** (`--access public`; requires an `NPM_TOKEN` repo secret with publish rights to the `@worldcoin` npm org, same as minikit-js / idkit-js) and a backup mirror to **GitHub Packages** (`GITHUB_TOKEN`). They run independently so one failing doesn't block the other; both use `--ignore-scripts`. Android stays on GitHub Packages (Maven).
+
+`publish-release.yml` only publishes the first time it creates the `v*` tag. Reruns after that tag exists skip the publish jobs.
+
+The verification workflow (`.github/workflows/verify.yml`) runs `format:check`, `lint`, `typecheck`, `build`, and the codegen-in-sync check on every push to `main` and every PR.
+
+## Example apps
+
+- `examples/android/` — Android demo with `local` and `package` flavors
+- `examples/ios/` — iOS demo with `Local` and `Package` schemes
+- `examples/web/` — Next.js demo with `local` and `package` token sources

package/VERSION

@@ -0,0 +1 @@
+0.1.4

package/android/.editorconfig

@@ -0,0 +1,19 @@
+root = true
+
+[*.{kt,kts}]
+# General
+indent_size = 4
+max_line_length = 120
+insert_final_newline = true
+ij_kotlin_allow_trailing_comma = true
+ij_kotlin_allow_trailing_comma_on_call_site = true
+ktlint_standard_no-wildcard-imports = enabled
+
+# Compose Specifics
+ktlint_function_naming_ignore_when_annotated_with = Composable
+ktlint_standard_multiline-expression-wrapping = disabled
+
+# Constructor Styling
+ktlint_standard_class-signature = disabled
+ktlint_standard_annotation = disabled
+ktlint_standard_parameter-list-wrapping = enabled

package/android/Makefile

@@ -0,0 +1,7 @@
+.PHONY: format
+format:
+	./gradlew ktlintFormat
+
+.PHONY: lint
+lint:
+	./gradlew ktlintCheck

package/android/build.gradle.kts

@@ -0,0 +1,30 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+plugins {
+    alias(libs.plugins.android.library) apply false
+    alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.ktlint) apply false
+}
+
+val copyPreCommitHook by tasks.registering(Copy::class) {
+    from("scripts/pre-commit")
+    into("../.git/hooks")
+    filePermissions {
+        user {
+            read = true
+            write = true
+            execute = true
+        }
+        group {
+            read = true
+            execute = true
+        }
+        other {
+            read = true
+            execute = true
+        }
+    }
+}
+
+tasks.named("prepareKotlinBuildScriptModel") {
+    dependsOn(copyPreCommitHook)
+}

package/android/gradle/libs.versions.toml

@@ -0,0 +1,28 @@
+[versions]
+agp = "9.2.0"
+kotlin = "2.0.21"
+coreKtx = "1.12.0"
+appcompat = "1.7.1"
+material = "1.12.0"
+composeBom = "2025.12.00"
+coil = "3.0.4"
+ktlint = "14.2.0"
+
+[libraries]
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
+material = { group = "com.google.android.material", name = "material", version.ref = "material" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
+androidx-compose-foundation = { group = "androidx.compose.foundation", name = "foundation" }
+androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
+androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
+androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
+androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
+coil-compose = { group = "io.coil-kt.coil3", name = "coil-compose", version.ref = "coil" }
+coil-network-okhttp = { group = "io.coil-kt.coil3", name = "coil-network-okhttp", version.ref = "coil" }
+
+[plugins]
+android-library = { id = "com.android.library", version.ref = "agp" }
+kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "ktlint" }

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,9 @@
+#Mon Apr 27 21:49:22 PDT 2026
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionSha256Sum=2ab2958f2a1e51120c326cad6f385153bb11ee93b3c216c5fccebfdfbb7ec6cb
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/android/gradle.properties

@@ -0,0 +1,3 @@
+kotlin.code.style=official
+org.gradle.caching=true
+android.enableJetifier=false

package/android/gradlew

@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed 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
+#
+#      https://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 CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH="\\\"\\\""
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"