Minification-Induced Symbol Loss in Production Titanium SDK Builds

Answer

To keep function‑name introspection, parameter inspection, or computed require() calls working in both development and production Titanium builds, you must either preserve the symbols that minification removes or avoid relying on them altogether.

Likely explanation

Production builds run the JavaScript optimizer (UglifyJS in older SDKs, Terser in SDK 10.x+) via the --optimize flag. This step mangles local variable/function names and eliminates any require() call whose argument is not a static string literal that the optimizer can resolve at build time. Development builds skip this step (--no-optimize), so original symbol names and dynamic requires remain intact, creating the observed behavioral gap.

Confirmed facts

• There is no supported annotation like /* @no-minify */ to preserve individual symbols.
• The only documented way to keep symbols is to disable optimization globally: set <property name="ti.android.optimize.js" type="bool">false</property> in tiapp.xml or run ti build --no-optimize. This increases bundle size roughly 30‑50 % and reduces obfuscation.
• Source maps (.map files) are generated for production builds but they only map positions for debugging; they do not restore Function.name values or prevent the removal of dynamic require() calls.
• Community work‑arounds that survive minification include: assigning critical functions to exports with string keys (exports['myFunc'] = myFunc), replacing computed require() with a static registry map, avoiding reliance on Function.name or Function.prototype.toString() for logic, and passing symbols via Ti.App.Properties or Ti.App.getArguments().
• An undocumented CLI option --minify-exclude exists in recent SDKs; it accepts file globs (not symbol patterns) to keep entire files unminified.

Steps needed for this case

1. Identify the symbols you need – list functions whose name property is inspected, and any modules loaded via a variable path.
2. Replace dynamic requires – build a static map like const MODS = { foo: require('foo'), bar: require('bar') } and use MODS[moduleName]. If a true dynamic path is unavoidable, move that code into a separate file and add that file to --minify-exclude (verify the flag works in your SDK version).
3. Preserve function names – for each inspected function, export it with a string key: exports['inspectMe'] = function inspectMe() { … }. Access it later via exports['inspectMe'] or require('mymodule')['inspectMe'].
4. Avoid name‑based logic – if you only need the function for calling, pass the function reference directly instead of looking it up by name.
5. If you must keep optimization off for a subset – try the undocumented ti build --minify-exclude "path/to/special/**/*.js" flag; otherwise, accept the global --no-optimize trade‑off after measuring bundle size.
6. Verify – after a production build, check the generated Resources/app.js (or platform‑specific bundle) to ensure the identified functions still appear with their original names or are accessed via the export map.

Missing diagnostic detail

The exact behavior of --minify-exclude and the optimizer version (UglifyJS vs. Terser) depend on your Titanium SDK version. Knowing whether you are on SDK 9.x or SDK 10.x+ would confirm if this flag is available and what its syntax is, which could change the recommendation from a global disable‑optimization approach to a selective exclude.