feat(smart-app): implement complete mobile app MVP

- App.tsx: full navigation (Auth stack + Main tabs with 5 screens)
- Auth: LoginScreen, RegisterScreen, ForgotPasswordScreen
- HomeScreen: dashboard with IoT metrics, weather widget, alerts, quick actions, sensors
- MapScreen: interactive map with layer toggles (6 layers)
- MarketplaceScreen: categories (6), products (5), search
- ChatScreen: AI chat with quick prompts (4), bot responses
- ProfileScreen: user info, stats, menu (9 items), logout
- AlertsScreen: alert list with severity, acknowledge
- SensorsScreen: sensor list with type filters (6 types), search
- ZonesScreen: zone cards with stats
- SettingsScreen: language picker (FR/EN/ES/DE), privacy, about
- Stores: iotStore (sensors, zones, alerts), notificationStore, uiStore + i18n
- Hooks: useSensors, useAlerts, useNotifications, useLocation
- Components: Card, Button, LoadingSpinner, ErrorBoundary, Header
- Services: iotService, notificationService (with axios API client)
- Utils: formatters (temp, AQI, noise, dates), validators (email, password, IBAN)
- Theme: colors.ts with full design system (Blue Ocean palette)
- Ditto: fixed MongoDB connection, new JWT secrets, official gateway image

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/clearNativeFolder.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    clearNativeFolder: ()=>clearNativeFolder,
+    hasRequiredAndroidFilesAsync: ()=>hasRequiredAndroidFilesAsync,
+    hasRequiredIOSFilesAsync: ()=>hasRequiredIOSFilesAsync,
+    getMalformedNativeProjectsAsync: ()=>getMalformedNativeProjectsAsync,
+    promptToClearMalformedNativeProjectsAsync: ()=>promptToClearMalformedNativeProjectsAsync
+});
+function _configPlugins() {
+    const data = require("@expo/config-plugins");
+    _configPlugins = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("../log"));
+const _dir = require("../utils/dir");
+const _interactive = require("../utils/interactive");
+const _ora = require("../utils/ora");
+const _prompts = require("../utils/prompts");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+async function clearNativeFolder(projectRoot, folders) {
+    const step = (0, _ora.logNewSection)(`Clearing ${folders.join(", ")}`);
+    try {
+        await Promise.all(folders.map((folderName)=>_fs().default.promises.rm(_path().default.join(projectRoot, folderName), {
+                recursive: true,
+                force: true
+            })));
+        step.succeed(`Cleared ${folders.join(", ")} code`);
+    } catch (error) {
+        step.fail(`Failed to delete ${folders.join(", ")} code: ${error.message}`);
+        throw error;
+    }
+}
+async function hasRequiredAndroidFilesAsync(projectRoot) {
+    try {
+        await Promise.all([
+            _configPlugins().AndroidConfig.Paths.getAppBuildGradleAsync(projectRoot),
+            _configPlugins().AndroidConfig.Paths.getProjectBuildGradleAsync(projectRoot),
+            _configPlugins().AndroidConfig.Paths.getAndroidManifestAsync(projectRoot),
+            _configPlugins().AndroidConfig.Paths.getMainApplicationAsync(projectRoot), 
+        ]);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function hasRequiredIOSFilesAsync(projectRoot) {
+    try {
+        // If any of the following required files are missing, then the project is malformed.
+        await Promise.all([
+            _configPlugins().IOSConfig.Paths.getAllXcodeProjectPaths(projectRoot),
+            _configPlugins().IOSConfig.Paths.getAllPBXProjectPaths(projectRoot), 
+        ]);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Filter out platforms that do not have an existing platform folder.
+ * If the user wants to validate that neither of ['ios', 'android'] are malformed then we should
+ * first check that both `ios` and `android` folders exist.
+ *
+ * This optimization prevents us from prompting to clear a "malformed" project that doesn't exist yet.
+ */ async function filterPlatformsThatDoNotExistAsync(projectRoot, platforms) {
+    const valid = await Promise.all(platforms.map(async (platform)=>{
+        if (await (0, _dir.directoryExistsAsync)(_path().default.join(projectRoot, platform))) {
+            return platform;
+        }
+        return null;
+    }));
+    return valid.filter(Boolean);
+}
+async function getMalformedNativeProjectsAsync(projectRoot, platforms) {
+    const VERIFIERS = {
+        android: hasRequiredAndroidFilesAsync,
+        ios: hasRequiredIOSFilesAsync
+    };
+    const checkablePlatforms = platforms.filter((platform)=>platform in VERIFIERS);
+    const checkPlatforms = await filterPlatformsThatDoNotExistAsync(projectRoot, checkablePlatforms);
+    return (await Promise.all(checkPlatforms.map(async (platform)=>{
+        if (!VERIFIERS[platform]) {
+            return false;
+        }
+        if (await VERIFIERS[platform](projectRoot)) {
+            return false;
+        }
+        return platform;
+    }))).filter(Boolean);
+}
+async function promptToClearMalformedNativeProjectsAsync(projectRoot, checkPlatforms) {
+    const platforms = await getMalformedNativeProjectsAsync(projectRoot, checkPlatforms);
+    if (!platforms.length) {
+        return;
+    }
+    const displayPlatforms = platforms.map((platform)=>_chalk().default.cyan(platform));
+    // Prompt which platforms to reset.
+    const message = platforms.length > 1 ? `The ${displayPlatforms[0]} and ${displayPlatforms[1]} projects are malformed` : `The ${displayPlatforms[0]} project is malformed`;
+    if (// If the process is non-interactive, default to clearing the malformed native project.
+    // This would only happen on re-running prebuild.
+    !(0, _interactive.isInteractive)() || // Prompt to clear the native folders.
+    (await (0, _prompts.confirmAsync)({
+        message: `${message}, would you like to clear the project files and reinitialize them?`,
+        initial: true
+    }))) {
+        if (!(0, _interactive.isInteractive)()) {
+            _log.warn(`${message}, project files will be cleared and reinitialized.`);
+        }
+        await clearNativeFolder(projectRoot, platforms);
+    } else {
+        // Warn the user that the process may fail.
+        _log.warn("Continuing with malformed native projects");
+    }
+}
+
+//# sourceMappingURL=clearNativeFolder.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/configureProjectAsync.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "configureProjectAsync", {
+    enumerable: true,
+    get: ()=>configureProjectAsync
+});
+function _configPlugins() {
+    const data = require("@expo/config-plugins");
+    _configPlugins = function() {
+        return data;
+    };
+    return data;
+}
+function _prebuildConfig() {
+    const data = require("@expo/prebuild-config");
+    _prebuildConfig = function() {
+        return data;
+    };
+    return data;
+}
+const _configAsync = require("../config/configAsync");
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("../log"));
+const _env = require("../utils/env");
+const _getOrPromptApplicationId = require("../utils/getOrPromptApplicationId");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+async function configureProjectAsync(projectRoot, { platforms , exp , templateChecksum  }) {
+    let bundleIdentifier;
+    if (platforms.includes("ios")) {
+        // Check bundle ID before reading the config because it may mutate the config if the user is prompted to define it.
+        bundleIdentifier = await (0, _getOrPromptApplicationId.getOrPromptForBundleIdentifier)(projectRoot, exp);
+    }
+    let packageName;
+    if (platforms.includes("android")) {
+        // Check package before reading the config because it may mutate the config if the user is prompted to define it.
+        packageName = await (0, _getOrPromptApplicationId.getOrPromptForPackage)(projectRoot, exp);
+    }
+    let { exp: config  } = await (0, _prebuildConfig().getPrebuildConfigAsync)(projectRoot, {
+        platforms,
+        packageName,
+        bundleIdentifier
+    });
+    if (templateChecksum) {
+        var __internal;
+        // Prepare template checksum for the patch mods
+        config._internal = (__internal = config._internal) != null ? __internal : {};
+        config._internal.templateChecksum = templateChecksum;
+    }
+    // compile all plugins and mods
+    config = await (0, _configPlugins().compileModsAsync)(config, {
+        projectRoot,
+        platforms,
+        assertMissingModProviders: false
+    });
+    if (_env.env.EXPO_DEBUG) {
+        _log.log();
+        _log.log("Evaluated config:");
+        (0, _configAsync.logConfig)(config);
+        _log.log();
+    }
+    return config;
+}
+
+//# sourceMappingURL=configureProjectAsync.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/configureProjectAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/prebuild/configureProjectAsync.ts"],"sourcesContent":["import { ExpoConfig } from '@expo/config';\nimport { compileModsAsync, ModPlatform } from '@expo/config-plugins';\nimport { getPrebuildConfigAsync } from '@expo/prebuild-config';\n\nimport { logConfig } from '../config/configAsync';\nimport * as Log from '../log';\nimport { env } from '../utils/env';\nimport {\n  getOrPromptForBundleIdentifier,\n  getOrPromptForPackage,\n} from '../utils/getOrPromptApplicationId';\n\nexport async function configureProjectAsync(\n  projectRoot: string,\n  {\n    platforms,\n    exp,\n    templateChecksum,\n  }: {\n    platforms: ModPlatform[];\n    exp?: ExpoConfig;\n    templateChecksum?: string;\n  }\n): Promise<ExpoConfig> {\n  let bundleIdentifier: string | undefined;\n  if (platforms.includes('ios')) {\n    // Check bundle ID before reading the config because it may mutate the config if the user is prompted to define it.\n    bundleIdentifier = await getOrPromptForBundleIdentifier(projectRoot, exp);\n  }\n  let packageName: string | undefined;\n  if (platforms.includes('android')) {\n    // Check package before reading the config because it may mutate the config if the user is prompted to define it.\n    packageName = await getOrPromptForPackage(projectRoot, exp);\n  }\n\n  let { exp: config } = await getPrebuildConfigAsync(projectRoot, {\n    platforms,\n    packageName,\n    bundleIdentifier,\n  });\n\n  if (templateChecksum) {\n    // Prepare template checksum for the patch mods\n    config._internal = config._internal ?? {};\n    config._internal.templateChecksum = templateChecksum;\n  }\n\n  // compile all plugins and mods\n  config = await compileModsAsync(config, {\n    projectRoot,\n    platforms,\n    assertMissingModProviders: false,\n  });\n\n  if (env.EXPO_DEBUG) {\n    Log.log();\n    Log.log('Evaluated config:');\n    logConfig(config);\n    Log.log();\n  }\n\n  return config;\n}\n"],"names":["configureProjectAsync","projectRoot","platforms","exp","templateChecksum","bundleIdentifier","includes","getOrPromptForBundleIdentifier","packageName","getOrPromptForPackage","config","getPrebuildConfigAsync","_internal","compileModsAsync","assertMissingModProviders","env","EXPO_DEBUG","Log","log","logConfig"],"mappings":"AAAA;;;;+BAYsBA,uBAAqB;;aAArBA,qBAAqB;;;yBAXG,sBAAsB;;;;;;;yBAC7B,uBAAuB;;;;;;6BAEpC,uBAAuB;2DAC5B,QAAQ;qBACT,cAAc;0CAI3B,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnC,eAAeA,qBAAqB,CACzCC,WAAmB,EACnB,EACEC,SAAS,CAAA,EACTC,GAAG,CAAA,EACHC,gBAAgB,CAAA,EAKjB,EACoB;IACrB,IAAIC,gBAAgB,AAAoB,AAAC;IACzC,IAAIH,SAAS,CAACI,QAAQ,CAAC,KAAK,CAAC,EAAE;QAC7B,mHAAmH;QACnHD,gBAAgB,GAAG,MAAME,IAAAA,yBAA8B,+BAAA,EAACN,WAAW,EAAEE,GAAG,CAAC,CAAC;IAC5E,CAAC;IACD,IAAIK,WAAW,AAAoB,AAAC;IACpC,IAAIN,SAAS,CAACI,QAAQ,CAAC,SAAS,CAAC,EAAE;QACjC,iHAAiH;QACjHE,WAAW,GAAG,MAAMC,IAAAA,yBAAqB,sBAAA,EAACR,WAAW,EAAEE,GAAG,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,EAAEA,GAAG,EAAEO,MAAM,CAAA,EAAE,GAAG,MAAMC,IAAAA,eAAsB,EAAA,uBAAA,EAACV,WAAW,EAAE;QAC9DC,SAAS;QACTM,WAAW;QACXH,gBAAgB;KACjB,CAAC,AAAC;IAEH,IAAID,gBAAgB,EAAE;YAEDM,UAAgB;QADnC,+CAA+C;QAC/CA,MAAM,CAACE,SAAS,GAAGF,CAAAA,UAAgB,GAAhBA,MAAM,CAACE,SAAS,YAAhBF,UAAgB,GAAI,EAAE,CAAC;QAC1CA,MAAM,CAACE,SAAS,CAACR,gBAAgB,GAAGA,gBAAgB,CAAC;IACvD,CAAC;IAED,+BAA+B;IAC/BM,MAAM,GAAG,MAAMG,IAAAA,cAAgB,EAAA,iBAAA,EAACH,MAAM,EAAE;QACtCT,WAAW;QACXC,SAAS;QACTY,yBAAyB,EAAE,KAAK;KACjC,CAAC,CAAC;IAEH,IAAIC,IAAG,IAAA,CAACC,UAAU,EAAE;QAClBC,IAAG,CAACC,GAAG,EAAE,CAAC;QACVD,IAAG,CAACC,GAAG,CAAC,mBAAmB,CAAC,CAAC;QAC7BC,IAAAA,YAAS,UAAA,EAACT,MAAM,CAAC,CAAC;QAClBO,IAAG,CAACC,GAAG,EAAE,CAAC;IACZ,CAAC;IAED,OAAOR,MAAM,CAAC;AAChB,CAAC"}

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/copyTemplateFiles.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createCopyFilesSuccessMessage: ()=>createCopyFilesSuccessMessage,
+    copyTemplateFiles: ()=>copyTemplateFiles
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _dir = require("../utils/dir");
+const _mergeGitIgnorePaths = require("../utils/mergeGitIgnorePaths");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require("debug")("expo:prebuild:copyTemplateFiles");
+/**
+ * Return true if the given platforms all have an internal `.gitignore` file.
+ *
+ * @param projectRoot
+ * @param platforms
+ */ function hasAllPlatformSpecificGitIgnores(projectRoot, platforms) {
+    return platforms.reduce((p, platform)=>p && _fs().default.existsSync(_path().default.join(projectRoot, platform, ".gitignore")), true);
+}
+function createCopyFilesSuccessMessage(platforms, { skippedPaths , gitignore  }) {
+    const pluralized = platforms.length > 1 ? "directories" : "directory";
+    let message = `Created native ${pluralized}`;
+    if (skippedPaths.length) {
+        message += _chalk().default.dim(` | reusing ${skippedPaths.map((path)=>_chalk().default.bold(`/${path}`)).join(", ")}`);
+    }
+    if (!gitignore) {
+    // Add no additional message...
+    } else if (!gitignore.didMerge) {
+        message += _chalk().default.dim(` | reusing gitignore`);
+    } else if (gitignore.didMerge && gitignore.didClear) {
+        // This is legacy and for non-standard templates. The Expo template adds gitignores to the platform folders.
+        message += _chalk().default.dim(` | updated gitignore`);
+    }
+    return message;
+}
+function copyTemplateFiles(projectRoot, { templateDirectory , platforms  }) {
+    const copiedPaths = [];
+    const skippedPaths = [];
+    platforms.forEach((copyFilePath)=>{
+        const projectPath = _path().default.join(projectRoot, copyFilePath);
+        if (_fs().default.existsSync(projectPath)) {
+            skippedPaths.push(copyFilePath);
+        } else {
+            copiedPaths.push(copyFilePath);
+            (0, _dir.copySync)(_path().default.join(templateDirectory, copyFilePath), projectPath);
+        }
+    });
+    const hasPlatformSpecificGitIgnores = hasAllPlatformSpecificGitIgnores(templateDirectory, platforms);
+    debug(`All platforms have an internal gitignore: ${hasPlatformSpecificGitIgnores}`);
+    // TODO: Remove gitignore modifications -- maybe move to `npx expo-doctor`
+    const gitignore = hasPlatformSpecificGitIgnores ? null : (0, _mergeGitIgnorePaths.mergeGitIgnorePaths)(_path().default.join(projectRoot, ".gitignore"), _path().default.join(templateDirectory, ".gitignore"));
+    return {
+        copiedPaths,
+        skippedPaths,
+        gitignore
+    };
+}
+
+//# sourceMappingURL=copyTemplateFiles.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/ensureConfigAsync.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ensureConfigExistsAsync: ()=>ensureConfigExistsAsync,
+    ensureConfigAsync: ()=>ensureConfigAsync
+});
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+function _jsonFile() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("@expo/json-file"));
+    _jsonFile = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("../log"));
+const _errors = require("../utils/errors");
+const _getOrPromptApplicationId = require("../utils/getOrPromptApplicationId");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+async function ensureConfigExistsAsync(projectRoot) {
+    try {
+        const config = (0, _config().getConfig)(projectRoot, {
+            skipSDKVersionRequirement: false
+        });
+        // If no config exists in the file system then we should generate one so the process doesn't fail.
+        if (!config.dynamicConfigPath && !config.staticConfigPath) {
+            // Remove the internal object before writing.
+            delete config.exp._internal;
+            // Write the generated config.
+            await _jsonFile().default.writeAsync(_path().default.join(projectRoot, "app.json"), {
+                expo: config.exp
+            }, {
+                json5: false
+            });
+        }
+    } catch (error) {
+        // TODO(Bacon): Currently this is already handled in the command
+        _log.log();
+        throw new _errors.CommandError(`${error.message}\n`);
+    }
+}
+async function ensureConfigAsync(projectRoot, { platforms  }) {
+    await ensureConfigExistsAsync(projectRoot);
+    // Prompt for the Android package first because it's more strict than the bundle identifier
+    // this means you'll have a better chance at matching the bundle identifier with the package name.
+    if (platforms.includes("android")) {
+        await (0, _getOrPromptApplicationId.getOrPromptForPackage)(projectRoot);
+    }
+    if (platforms.includes("ios")) {
+        await (0, _getOrPromptApplicationId.getOrPromptForBundleIdentifier)(projectRoot);
+    }
+    // Read config again because prompting for bundle id or package name may have mutated the results.
+    return (0, _config().getConfig)(projectRoot);
+}
+
+//# sourceMappingURL=ensureConfigAsync.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/ensureConfigAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/prebuild/ensureConfigAsync.ts"],"sourcesContent":["import { ExpoConfig, getConfig, PackageJSONConfig } from '@expo/config';\nimport { ModPlatform } from '@expo/config-plugins';\nimport JsonFile, { JSONObject } from '@expo/json-file';\nimport path from 'path';\n\nimport * as Log from '../log';\nimport { CommandError } from '../utils/errors';\nimport {\n  getOrPromptForBundleIdentifier,\n  getOrPromptForPackage,\n} from '../utils/getOrPromptApplicationId';\n\n/**\n * If an Expo config file does not exist, write a new one using the in-memory config.\n *\n * @param projectRoot\n */\nexport async function ensureConfigExistsAsync(projectRoot: string) {\n  try {\n    const config = getConfig(projectRoot, { skipSDKVersionRequirement: false });\n    // If no config exists in the file system then we should generate one so the process doesn't fail.\n    if (!config.dynamicConfigPath && !config.staticConfigPath) {\n      // Remove the internal object before writing.\n      delete config.exp._internal;\n\n      // Write the generated config.\n      await JsonFile.writeAsync(\n        path.join(projectRoot, 'app.json'),\n        { expo: config.exp as unknown as JSONObject },\n        { json5: false }\n      );\n    }\n  } catch (error: any) {\n    // TODO(Bacon): Currently this is already handled in the command\n    Log.log();\n    throw new CommandError(`${error.message}\\n`);\n  }\n}\n\n/** Ensure config is written, and prompts for application identifiers. */\nexport async function ensureConfigAsync(\n  projectRoot: string,\n  {\n    platforms,\n  }: {\n    platforms: ModPlatform[];\n  }\n): Promise<{ exp: ExpoConfig; pkg: PackageJSONConfig }> {\n  await ensureConfigExistsAsync(projectRoot);\n\n  // Prompt for the Android package first because it's more strict than the bundle identifier\n  // this means you'll have a better chance at matching the bundle identifier with the package name.\n  if (platforms.includes('android')) {\n    await getOrPromptForPackage(projectRoot);\n  }\n\n  if (platforms.includes('ios')) {\n    await getOrPromptForBundleIdentifier(projectRoot);\n  }\n\n  // Read config again because prompting for bundle id or package name may have mutated the results.\n  return getConfig(projectRoot);\n}\n"],"names":["ensureConfigExistsAsync","ensureConfigAsync","projectRoot","config","getConfig","skipSDKVersionRequirement","dynamicConfigPath","staticConfigPath","exp","_internal","JsonFile","writeAsync","path","join","expo","json5","error","Log","log","CommandError","message","platforms","includes","getOrPromptForPackage","getOrPromptForBundleIdentifier"],"mappings":"AAAA;;;;;;;;;;;IAiBsBA,uBAAuB,MAAvBA,uBAAuB;IAuBvBC,iBAAiB,MAAjBA,iBAAiB;;;yBAxCkB,cAAc;;;;;;;8DAElC,iBAAiB;;;;;;;8DACrC,MAAM;;;;;;2DAEF,QAAQ;wBACA,iBAAiB;0CAIvC,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOnC,eAAeD,uBAAuB,CAACE,WAAmB,EAAE;IACjE,IAAI;QACF,MAAMC,MAAM,GAAGC,IAAAA,OAAS,EAAA,UAAA,EAACF,WAAW,EAAE;YAAEG,yBAAyB,EAAE,KAAK;SAAE,CAAC,AAAC;QAC5E,kGAAkG;QAClG,IAAI,CAACF,MAAM,CAACG,iBAAiB,IAAI,CAACH,MAAM,CAACI,gBAAgB,EAAE;YACzD,6CAA6C;YAC7C,OAAOJ,MAAM,CAACK,GAAG,CAACC,SAAS,CAAC;YAE5B,8BAA8B;YAC9B,MAAMC,SAAQ,EAAA,QAAA,CAACC,UAAU,CACvBC,KAAI,EAAA,QAAA,CAACC,IAAI,CAACX,WAAW,EAAE,UAAU,CAAC,EAClC;gBAAEY,IAAI,EAAEX,MAAM,CAACK,GAAG;aAA2B,EAC7C;gBAAEO,KAAK,EAAE,KAAK;aAAE,CACjB,CAAC;QACJ,CAAC;IACH,EAAE,OAAOC,KAAK,EAAO;QACnB,gEAAgE;QAChEC,IAAG,CAACC,GAAG,EAAE,CAAC;QACV,MAAM,IAAIC,OAAY,aAAA,CAAC,CAAC,EAAEH,KAAK,CAACI,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC;AAGM,eAAenB,iBAAiB,CACrCC,WAAmB,EACnB,EACEmB,SAAS,CAAA,EAGV,EACqD;IACtD,MAAMrB,uBAAuB,CAACE,WAAW,CAAC,CAAC;IAE3C,2FAA2F;IAC3F,kGAAkG;IAClG,IAAImB,SAAS,CAACC,QAAQ,CAAC,SAAS,CAAC,EAAE;QACjC,MAAMC,IAAAA,yBAAqB,sBAAA,EAACrB,WAAW,CAAC,CAAC;IAC3C,CAAC;IAED,IAAImB,SAAS,CAACC,QAAQ,CAAC,KAAK,CAAC,EAAE;QAC7B,MAAME,IAAAA,yBAA8B,+BAAA,EAACtB,WAAW,CAAC,CAAC;IACpD,CAAC;IAED,kGAAkG;IAClG,OAAOE,IAAAA,OAAS,EAAA,UAAA,EAACF,WAAW,CAAC,CAAC;AAChC,CAAC"}

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/index.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "expoPrebuild", {
+    enumerable: true,
+    get: ()=>expoPrebuild
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _args = require("../utils/args");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const expoPrebuild = async (argv)=>{
+    const args = (0, _args.assertArgs)({
+        // Types
+        "--help": Boolean,
+        "--clean": Boolean,
+        "--npm": Boolean,
+        "--pnpm": Boolean,
+        "--yarn": Boolean,
+        "--bun": Boolean,
+        "--no-install": Boolean,
+        "--template": String,
+        "--platform": String,
+        "--skip-dependency-update": String,
+        // Aliases
+        "-h": "--help",
+        "-p": "--platform",
+        "-t": "--type"
+    }, argv);
+    if (args["--help"]) {
+        (0, _args.printHelp)(`Create native iOS and Android project files for building natively`, (0, _chalk().default)`npx expo prebuild {dim <dir>}`, [
+            (0, _chalk().default)`<dir>                                    Directory of the Expo project. {dim Default: Current working directory}`,
+            `--no-install                             Skip installing npm packages and CocoaPods`,
+            `--clean                                  Delete the native folders and regenerate them before applying changes`,
+            (0, _chalk().default)`--npm                                    Use npm to install dependencies. {dim Default when package-lock.json exists}`,
+            (0, _chalk().default)`--yarn                                   Use Yarn to install dependencies. {dim Default when yarn.lock exists}`,
+            (0, _chalk().default)`--bun                                    Use bun to install dependencies. {dim Default when bun.lockb exists}`,
+            (0, _chalk().default)`--pnpm                                   Use pnpm to install dependencies. {dim Default when pnpm-lock.yaml exists}`,
+            `--template <template>                    Project template to clone from. File path pointing to a local tar file or a github repo`,
+            (0, _chalk().default)`-p, --platform <all|android|ios>         Platforms to sync: ios, android, all. {dim Default: all}`,
+            `--skip-dependency-update <dependencies>  Preserves versions of listed packages in package.json (comma separated list)`,
+            `-h, --help                               Usage info`, 
+        ].join("\n"));
+    }
+    // Load modules after the help prompt so `npx expo prebuild -h` shows as fast as possible.
+    const [// ./prebuildAsync
+    { prebuildAsync  }, // ./resolveOptions
+    { resolvePlatformOption , resolvePackageManagerOptions , resolveSkipDependencyUpdate  }, // ../utils/errors
+    { logCmdError  }, ] = await Promise.all([
+        Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("./prebuildAsync.js"))),
+        Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("./resolveOptions.js"))),
+        Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("../utils/errors.js"))), 
+    ]);
+    return (()=>{
+        return prebuildAsync((0, _args.getProjectRoot)(args), {
+            // Parsed options
+            clean: args["--clean"],
+            packageManager: resolvePackageManagerOptions(args),
+            install: !args["--no-install"],
+            platforms: resolvePlatformOption(args["--platform"]),
+            // TODO: Parse
+            skipDependencyUpdate: resolveSkipDependencyUpdate(args["--skip-dependency-update"]),
+            template: args["--template"]
+        });
+    })().catch(logCmdError);
+};
+
+//# sourceMappingURL=index.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/prebuildAsync.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "prebuildAsync", {
+    enumerable: true,
+    get: ()=>prebuildAsync
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _clearNativeFolder = require("./clearNativeFolder");
+const _configureProjectAsync = require("./configureProjectAsync");
+const _ensureConfigAsync = require("./ensureConfigAsync");
+const _resolveOptions = require("./resolveOptions");
+const _updateFromTemplate = require("./updateFromTemplate");
+const _installAsync = require("../install/installAsync");
+const _log = require("../log");
+const _env = require("../utils/env");
+const _nodeEnv = require("../utils/nodeEnv");
+const _nodeModules = require("../utils/nodeModules");
+const _ora = require("../utils/ora");
+const _profile = require("../utils/profile");
+const _prompts = require("../utils/prompts");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const debug = require("debug")("expo:prebuild");
+async function prebuildAsync(projectRoot, options) {
+    (0, _nodeEnv.setNodeEnv)("development");
+    require("@expo/env").load(projectRoot);
+    if (options.clean) {
+        const { maybeBailOnGitStatusAsync  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("../utils/git.js")));
+        // Clean the project folders...
+        if (await maybeBailOnGitStatusAsync()) {
+            return null;
+        }
+        // Clear the native folders before syncing
+        await (0, _clearNativeFolder.clearNativeFolder)(projectRoot, options.platforms);
+    } else {
+        // Check if the existing project folders are malformed.
+        await (0, _clearNativeFolder.promptToClearMalformedNativeProjectsAsync)(projectRoot, options.platforms);
+    }
+    // Warn if the project is attempting to prebuild an unsupported platform (iOS on Windows).
+    options.platforms = (0, _resolveOptions.ensureValidPlatforms)(options.platforms);
+    // Assert if no platforms are left over after filtering.
+    (0, _resolveOptions.assertPlatforms)(options.platforms);
+    // Get the Expo config, create it if missing.
+    const { exp , pkg  } = await (0, _ensureConfigAsync.ensureConfigAsync)(projectRoot, {
+        platforms: options.platforms
+    });
+    // Create native projects from template.
+    const { hasNewProjectFiles , needsPodInstall , templateChecksum , changedDependencies  } = await (0, _updateFromTemplate.updateFromTemplateAsync)(projectRoot, {
+        exp,
+        pkg,
+        template: options.template != null ? (0, _resolveOptions.resolveTemplateOption)(options.template) : undefined,
+        platforms: options.platforms,
+        skipDependencyUpdate: options.skipDependencyUpdate
+    });
+    // Install node modules
+    if (options.install) {
+        if (changedDependencies.length) {
+            var ref;
+            if ((ref = options.packageManager) == null ? void 0 : ref.npm) {
+                await (0, _nodeModules.clearNodeModulesAsync)(projectRoot);
+            }
+            _log.Log.log(_chalk().default.gray((0, _chalk().default)`Dependencies in the {bold package.json} changed:`));
+            _log.Log.log(_chalk().default.gray("  " + changedDependencies.join(", ")));
+            // Installing dependencies is a legacy feature from the unversioned
+            // command. We know opt to not change dependencies unless a template
+            // indicates a new dependency is required, or if the core dependencies are wrong.
+            if (await (0, _prompts.confirmAsync)({
+                message: `Install the updated dependencies?`,
+                initial: true
+            })) {
+                var ref1, ref2, ref3, ref4;
+                await (0, _installAsync.installAsync)([], {
+                    npm: !!((ref1 = options.packageManager) == null ? void 0 : ref1.npm),
+                    yarn: !!((ref2 = options.packageManager) == null ? void 0 : ref2.yarn),
+                    pnpm: !!((ref3 = options.packageManager) == null ? void 0 : ref3.pnpm),
+                    bun: !!((ref4 = options.packageManager) == null ? void 0 : ref4.bun),
+                    silent: !(_env.env.EXPO_DEBUG || _env.env.CI)
+                });
+            }
+        }
+    }
+    // Apply Expo config to native projects. Prevent log-spew from ora when running in debug mode.
+    const configSyncingStep = _env.env.EXPO_DEBUG ? {
+        succeed (text) {
+            _log.Log.log(text);
+        },
+        fail (text) {
+            _log.Log.error(text);
+        }
+    } : (0, _ora.logNewSection)("Running prebuild");
+    try {
+        await (0, _profile.profile)(_configureProjectAsync.configureProjectAsync)(projectRoot, {
+            platforms: options.platforms,
+            exp,
+            templateChecksum
+        });
+        configSyncingStep.succeed("Finished prebuild");
+    } catch (error) {
+        configSyncingStep.fail("Prebuild failed");
+        throw error;
+    }
+    // Install CocoaPods
+    let podsInstalled = false;
+    // err towards running pod install less because it's slow and users can easily run npx pod-install afterwards.
+    if (options.platforms.includes("ios") && options.install && needsPodInstall) {
+        const { installCocoaPodsAsync  } = await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("../utils/cocoapods.js")));
+        podsInstalled = await installCocoaPodsAsync(projectRoot);
+    } else {
+        debug("Skipped pod install");
+    }
+    return {
+        nodeInstall: !!options.install,
+        podInstall: !podsInstalled,
+        platforms: options.platforms,
+        hasNewProjectFiles,
+        exp
+    };
+}
+
+//# sourceMappingURL=prebuildAsync.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/renameTemplateAppName.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    defaultRenameConfig: ()=>defaultRenameConfig,
+    getTemplateFilesToRenameAsync: ()=>getTemplateFilesToRenameAsync,
+    renameTemplateAppNameAsync: ()=>renameTemplateAppNameAsync
+});
+function _configPlugins() {
+    const data = require("@expo/config-plugins");
+    _configPlugins = function() {
+        return data;
+    };
+    return data;
+}
+function _fastGlob() {
+    const data = require("fast-glob");
+    _fastGlob = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const debug = require("debug")("expo:prebuild:copyTemplateFiles");
+function escapeXMLCharacters(original) {
+    const noAmps = original.replace("&", "&");
+    const noLt = noAmps.replace("<", "&lt;");
+    const noGt = noLt.replace(">", "&gt;");
+    const noApos = noGt.replace('"', '\\"');
+    return noApos.replace("'", "\\'");
+}
+const defaultRenameConfig = [
+    // Common
+    "!**/node_modules",
+    "app.json",
+    // Android
+    "android/**/*.gradle",
+    "android/app/BUCK",
+    "android/app/src/**/*.java",
+    "android/app/src/**/*.kt",
+    "android/app/src/**/*.xml",
+    // iOS
+    "ios/Podfile",
+    "ios/**/*.xcodeproj/project.pbxproj",
+    "ios/**/*.xcodeproj/xcshareddata/xcschemes/*.xcscheme", 
+];
+async function getTemplateFilesToRenameAsync({ cwd , /**
+   * An array of patterns following the rename config format. If omitted, then
+   * we fall back to defaultRenameConfig.
+   * @see defaultRenameConfig
+   */ renameConfig: userConfig  }) {
+    let config = userConfig != null ? userConfig : defaultRenameConfig;
+    // Strip comments, trim whitespace, and remove empty lines.
+    config = config.map((line)=>line.split(/(?<!\\)#/, 2)[0].trim()).filter((line)=>line !== "");
+    return await (0, _fastGlob().glob)(config, {
+        cwd,
+        // `true` is consistent with .gitignore. Allows `*.xml` to match .xml files
+        // in all subdirs.
+        baseNameMatch: true,
+        dot: true,
+        // Prevent climbing out of the template directory in case a template
+        // includes a symlink to an external directory.
+        followSymbolicLinks: false
+    });
+}
+async function renameTemplateAppNameAsync({ cwd , name , files  }) {
+    debug(`Got files to transform: ${JSON.stringify(files)}`);
+    await Promise.all(files.map(async (file)=>{
+        const absoluteFilePath = _path().default.resolve(cwd, file);
+        let contents;
+        try {
+            contents = await _fs().default.promises.readFile(absoluteFilePath, {
+                encoding: "utf-8"
+            });
+        } catch (error) {
+            throw new Error(`Failed to read template file: "${absoluteFilePath}". Was it removed mid-operation?`, {
+                cause: error
+            });
+        }
+        debug(`Renaming app name in file: ${absoluteFilePath}`);
+        const safeName = [
+            ".xml",
+            ".plist"
+        ].includes(_path().default.extname(file)) ? escapeXMLCharacters(name) : name;
+        try {
+            const replacement = contents.replace(/Hello App Display Name/g, safeName).replace(/HelloWorld/g, _configPlugins().IOSConfig.XcodeUtils.sanitizedName(safeName)).replace(/helloworld/g, _configPlugins().IOSConfig.XcodeUtils.sanitizedName(safeName.toLowerCase()));
+            if (replacement === contents) {
+                return;
+            }
+            await _fs().default.promises.writeFile(absoluteFilePath, replacement);
+        } catch (error1) {
+            throw new Error(`Failed to overwrite template file: "${absoluteFilePath}". Was it removed mid-operation?`, {
+                cause: error1
+            });
+        }
+    }));
+}
+
+//# sourceMappingURL=renameTemplateAppName.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/resolveOptions.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    resolvePackageManagerOptions: ()=>resolvePackageManagerOptions,
+    resolveTemplateOption: ()=>resolveTemplateOption,
+    resolveSkipDependencyUpdate: ()=>resolveSkipDependencyUpdate,
+    resolvePlatformOption: ()=>resolvePlatformOption,
+    ensureValidPlatforms: ()=>ensureValidPlatforms,
+    assertPlatforms: ()=>assertPlatforms
+});
+function _assert() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("assert"));
+    _assert = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("../log"));
+const _errors = require("../utils/errors");
+const _url = require("../utils/url");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function resolvePackageManagerOptions(args) {
+    const managers = {
+        npm: args["--npm"],
+        yarn: args["--yarn"],
+        pnpm: args["--pnpm"],
+        bun: args["--bun"]
+    };
+    if ([
+        managers.npm,
+        managers.pnpm,
+        managers.yarn,
+        managers.bun,
+        !!args["--no-install"]
+    ].filter(Boolean).length > 1) {
+        throw new _errors.CommandError("BAD_ARGS", "Specify at most one of: --no-install, --npm, --pnpm, --yarn, --bun");
+    }
+    return managers;
+}
+function resolveTemplateOption(template) {
+    if ((0, _url.validateUrl)(template)) {
+        return template;
+    }
+    const templatePath = _path().default.resolve(template);
+    (0, _assert().default)(_fs().default.existsSync(templatePath), "template file does not exist: " + templatePath);
+    (0, _assert().default)(_fs().default.statSync(templatePath).isFile(), "template must be a tar file created by running `npm pack` in a project: " + templatePath);
+    return templatePath;
+}
+function resolveSkipDependencyUpdate(value) {
+    if (!value || typeof value !== "string") {
+        return [];
+    }
+    return value.split(",");
+}
+function resolvePlatformOption(platform = "all", { loose  } = {}) {
+    switch(platform){
+        case "ios":
+            return [
+                "ios"
+            ];
+        case "android":
+            return [
+                "android"
+            ];
+        case "all":
+            return loose || process.platform !== "win32" ? [
+                "android",
+                "ios"
+            ] : [
+                "android"
+            ];
+        default:
+            return [
+                platform
+            ];
+    }
+}
+function ensureValidPlatforms(platforms) {
+    // Skip prebuild for iOS on Windows
+    if (process.platform === "win32" && platforms.includes("ios")) {
+        _log.warn((0, _chalk().default)`⚠️  Skipping generating the iOS native project files. Run {bold npx expo prebuild} again from macOS or Linux to generate the iOS project.\n`);
+        return platforms.filter((platform)=>platform !== "ios");
+    }
+    return platforms;
+}
+function assertPlatforms(platforms) {
+    if (!(platforms == null ? void 0 : platforms.length)) {
+        throw new _errors.CommandError("At least one platform must be enabled when syncing");
+    }
+}
+
+//# sourceMappingURL=resolveOptions.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/resolveTemplate.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    cloneTemplateAsync: ()=>cloneTemplateAsync,
+    resolveTemplateArgAsync: ()=>resolveTemplateArgAsync
+});
+function _assert() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("assert"));
+    _assert = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+function _semver() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("semver"));
+    _semver = function() {
+        return data;
+    };
+    return data;
+}
+const _client = require("../api/rest/client");
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("../log"));
+const _createFileTransform = require("../utils/createFileTransform");
+const _errors = require("../utils/errors");
+const _npm = require("../utils/npm");
+const _url = require("../utils/url");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const debug = require("debug")("expo:prebuild:resolveTemplate");
+async function cloneTemplateAsync({ templateDirectory , template , exp , ora  }) {
+    if (template) {
+        return await resolveTemplateArgAsync(templateDirectory, ora, exp.name, template);
+    } else {
+        const templatePackageName = await getTemplateNpmPackageName(exp.sdkVersion);
+        return await (0, _npm.downloadAndExtractNpmModuleAsync)(templatePackageName, {
+            cwd: templateDirectory,
+            name: exp.name
+        });
+    }
+}
+/** Given an `sdkVersion` like `44.0.0` return a fully qualified NPM package name like: `expo-template-bare-minimum@sdk-44` */ function getTemplateNpmPackageName(sdkVersion) {
+    // When undefined or UNVERSIONED, we use the latest version.
+    if (!sdkVersion || sdkVersion === "UNVERSIONED") {
+        _log.log("Using an unspecified Expo SDK version. The latest template will be used.");
+        return `expo-template-bare-minimum@latest`;
+    }
+    return `expo-template-bare-minimum@sdk-${_semver().default.major(sdkVersion)}`;
+}
+async function getRepoInfo(url, examplePath) {
+    const [, username, name, t, _branch, ...file] = url.pathname.split("/");
+    const filePath = examplePath ? examplePath.replace(/^\//, "") : file.join("/");
+    // Support repos whose entire purpose is to be an example, e.g.
+    // https://github.com/:username/:my-cool-example-repo-name.
+    if (t === undefined) {
+        const infoResponse = await (0, _client.fetchAsync)(`https://api.github.com/repos/${username}/${name}`);
+        if (infoResponse.status !== 200) {
+            return;
+        }
+        const info = await infoResponse.json();
+        return {
+            username,
+            name,
+            branch: info["default_branch"],
+            filePath
+        };
+    }
+    // If examplePath is available, the branch name takes the entire path
+    const branch = examplePath ? `${_branch}/${file.join("/")}`.replace(new RegExp(`/${filePath}|/$`), "") : _branch;
+    if (username && name && branch && t === "tree") {
+        return {
+            username,
+            name,
+            branch,
+            filePath
+        };
+    }
+    return undefined;
+}
+function hasRepo({ username , name , branch , filePath  }) {
+    const contentsUrl = `https://api.github.com/repos/${username}/${name}/contents`;
+    const packagePath = `${filePath ? `/${filePath}` : ""}/package.json`;
+    return (0, _url.isUrlOk)(contentsUrl + packagePath + `?ref=${branch}`);
+}
+async function downloadAndExtractRepoAsync({ username , name , branch , filePath  }, props) {
+    const url = `https://codeload.github.com/${username}/${name}/tar.gz/${branch}`;
+    debug("Downloading tarball from:", url);
+    // Extract the (sub)directory into non-empty path segments
+    const directory = filePath.replace(/^\//, "").split("/").filter(Boolean);
+    // Remove the (sub)directory paths, and the root folder added by GitHub
+    const strip = directory.length + 1;
+    // Only extract the relevant (sub)directories, ignoring irrelevant files
+    // The filder auto-ignores dotfiles, unless explicitly included
+    const filter = (0, _createFileTransform.createGlobFilter)(!directory.length ? [
+        "*/**",
+        "*/ios/.xcode.env"
+    ] : [
+        `*/${directory.join("/")}/**`,
+        `*/${directory.join("/")}/ios/.xcode.env`
+    ], {
+        // Always ignore the `.xcworkspace` folder
+        ignore: [
+            "**/ios/*.xcworkspace/**"
+        ]
+    });
+    return await (0, _npm.extractNpmTarballFromUrlAsync)(url, {
+        ...props,
+        strip,
+        filter
+    });
+}
+async function resolveTemplateArgAsync(templateDirectory, oraInstance, appName, template, templatePath) {
+    (0, _assert().default)(template, "template is required");
+    let repoUrl;
+    try {
+        repoUrl = new URL(template);
+    } catch (error) {
+        if (error.code !== "ERR_INVALID_URL") {
+            oraInstance.fail(error);
+            throw error;
+        }
+    }
+    // On Windows, we can actually create a URL from a local path
+    // Double-check if the created URL is not a path to avoid mixing up URLs and paths
+    if (process.platform === "win32" && repoUrl && _path().default.isAbsolute(repoUrl.toString())) {
+        repoUrl = undefined;
+    }
+    if (!repoUrl) {
+        const templatePath1 = _path().default.resolve(template);
+        if (!_fs().default.existsSync(templatePath1)) {
+            throw new _errors.CommandError(`template file does not exist: ${templatePath1}`);
+        }
+        return await (0, _npm.extractLocalNpmTarballAsync)(templatePath1, {
+            cwd: templateDirectory,
+            name: appName
+        });
+    }
+    if (repoUrl.origin !== "https://github.com") {
+        oraInstance.fail(`Invalid URL: ${_chalk().default.red(`"${template}"`)}. Only GitHub repositories are supported. Please use a GitHub URL and try again.`);
+        throw new _errors.AbortCommandError();
+    }
+    const repoInfo = await getRepoInfo(repoUrl, templatePath);
+    if (!repoInfo) {
+        oraInstance.fail(`Found invalid GitHub URL: ${_chalk().default.red(`"${template}"`)}. Please fix the URL and try again.`);
+        throw new _errors.AbortCommandError();
+    }
+    const found = await hasRepo(repoInfo);
+    if (!found) {
+        oraInstance.fail(`Could not locate the repository for ${_chalk().default.red(`"${template}"`)}. Please check that the repository exists and try again.`);
+        throw new _errors.AbortCommandError();
+    }
+    oraInstance.text = _chalk().default.bold(`Downloading files from repo ${_chalk().default.cyan(template)}. This might take a moment.`);
+    return await downloadAndExtractRepoAsync(repoInfo, {
+        cwd: templateDirectory,
+        name: appName
+    });
+}
+
+//# sourceMappingURL=resolveTemplate.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/updateFromTemplate.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    updateFromTemplateAsync: ()=>updateFromTemplateAsync,
+    cloneTemplateAndCopyToProjectAsync: ()=>cloneTemplateAndCopyToProjectAsync
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+const _copyTemplateFiles = require("./copyTemplateFiles");
+const _renameTemplateAppName = require("./renameTemplateAppName");
+const _resolveTemplate = require("./resolveTemplate");
+const _updatePackageJson = require("./updatePackageJson");
+const _validateTemplatePlatforms = require("./validateTemplatePlatforms");
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("../log"));
+const _errors = require("../utils/errors");
+const _ora = require("../utils/ora");
+const _profile = require("../utils/profile");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+async function updateFromTemplateAsync(projectRoot, { exp , pkg , template , templateDirectory , platforms , skipDependencyUpdate  }) {
+    if (!templateDirectory) {
+        const temporary = await Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(require("tempy")));
+        templateDirectory = temporary.directory();
+    }
+    const { copiedPaths , templateChecksum  } = await (0, _profile.profile)(cloneTemplateAndCopyToProjectAsync)({
+        projectRoot,
+        template,
+        templateDirectory,
+        exp,
+        platforms
+    });
+    const depsResults = await (0, _profile.profile)(_updatePackageJson.updatePackageJSONAsync)(projectRoot, {
+        templateDirectory,
+        pkg,
+        skipDependencyUpdate
+    });
+    return {
+        hasNewProjectFiles: !!copiedPaths.length,
+        // If the iOS folder changes or new packages are added, we should rerun pod install.
+        needsPodInstall: copiedPaths.includes("ios") || !!depsResults.changedDependencies.length,
+        templateChecksum,
+        ...depsResults
+    };
+}
+async function cloneTemplateAndCopyToProjectAsync({ projectRoot , templateDirectory , template , exp , platforms: unknownPlatforms  }) {
+    const platformDirectories = unknownPlatforms.map((platform)=>`./${platform}`).reverse().join(" and ");
+    const pluralized = unknownPlatforms.length > 1 ? "directories" : "directory";
+    const ora = (0, _ora.logNewSection)(`Creating native ${pluralized} (${platformDirectories})`);
+    try {
+        const templateChecksum = await (0, _resolveTemplate.cloneTemplateAsync)({
+            templateDirectory,
+            template,
+            exp,
+            ora
+        });
+        const platforms = (0, _validateTemplatePlatforms.validateTemplatePlatforms)({
+            templateDirectory,
+            platforms: unknownPlatforms
+        });
+        const results = (0, _copyTemplateFiles.copyTemplateFiles)(projectRoot, {
+            templateDirectory,
+            platforms
+        });
+        const files = await (0, _renameTemplateAppName.getTemplateFilesToRenameAsync)({
+            cwd: projectRoot
+        });
+        await (0, _renameTemplateAppName.renameTemplateAppNameAsync)({
+            cwd: projectRoot,
+            files,
+            name: exp.name
+        });
+        // Says: "Created native directories"
+        ora.succeed((0, _copyTemplateFiles.createCopyFilesSuccessMessage)(platforms, results));
+        return {
+            copiedPaths: results.copiedPaths,
+            templateChecksum
+        };
+    } catch (e) {
+        if (!(e instanceof _errors.AbortCommandError)) {
+            _log.error(e.message);
+        }
+        ora.fail(`Failed to create the native ${pluralized}`);
+        _log.log(_chalk().default.yellow((0, _chalk().default)`You may want to delete the {bold ./ios} and/or {bold ./android} directories before trying again.`));
+        throw new _errors.SilentError(e);
+    }
+}
+
+//# sourceMappingURL=updateFromTemplate.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/updatePackageJson.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    updatePackageJSONAsync: ()=>updatePackageJSONAsync,
+    updatePkgDependencies: ()=>updatePkgDependencies,
+    createDependenciesMap: ()=>createDependenciesMap,
+    hashForDependencyMap: ()=>hashForDependencyMap,
+    createFileHash: ()=>createFileHash
+});
+function _config() {
+    const data = require("@expo/config");
+    _config = function() {
+        return data;
+    };
+    return data;
+}
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _crypto() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("crypto"));
+    _crypto = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+function _semver() {
+    const data = require("semver");
+    _semver = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("../log"));
+const _isModuleSymlinked = require("../utils/isModuleSymlinked");
+const _ora = require("../utils/ora");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+async function updatePackageJSONAsync(projectRoot, { templateDirectory , templatePkg =(0, _config().getPackageJson)(templateDirectory) , pkg , skipDependencyUpdate  }) {
+    const updatingPackageJsonStep = (0, _ora.logNewSection)("Updating package.json");
+    const results = modifyPackageJson(projectRoot, {
+        templatePkg,
+        pkg,
+        skipDependencyUpdate
+    });
+    const hasChanges = results.changedDependencies.length || results.scriptsChanged;
+    // NOTE: This is effectively bundler caching and subject to breakage if the inputs don't match the mutations.
+    if (hasChanges) {
+        await _fs().default.promises.writeFile(_path().default.resolve(projectRoot, "package.json"), // Add new line to match the format of running yarn.
+        // This prevents the `package.json` from changing when running `prebuild --no-install` multiple times.
+        JSON.stringify(pkg, null, 2) + "\n");
+    }
+    updatingPackageJsonStep.succeed("Updated package.json" + (hasChanges ? "" : _chalk().default.dim(` | no changes`)));
+    return results;
+}
+/**
+ * Make required modifications to the `package.json` file as a JSON object.
+ *
+ * 1. Update `package.json` `scripts`.
+ * 2. Update `package.json` `dependencies` (not `devDependencies`).
+ * 3. Update `package.json` `main`.
+ *
+ * @param projectRoot The root directory of the project.
+ * @param props.templatePkg Template project package.json as JSON.
+ * @param props.pkg Current package.json as JSON.
+ * @param props.skipDependencyUpdate Array of dependencies to skip updating.
+ * @returns
+ */ function modifyPackageJson(projectRoot, { templatePkg , pkg , skipDependencyUpdate  }) {
+    const scriptsChanged = updatePkgScripts({
+        pkg
+    });
+    // TODO: Move to `npx expo-doctor`
+    return {
+        scriptsChanged,
+        ...updatePkgDependencies(projectRoot, {
+            pkg,
+            templatePkg,
+            skipDependencyUpdate
+        })
+    };
+}
+function updatePkgDependencies(projectRoot, { pkg , templatePkg , skipDependencyUpdate =[]  }) {
+    const { dependencies  } = templatePkg;
+    // The default values come from the bare-minimum template's package.json.
+    // Users can change this by using different templates with the `--template` flag.
+    // The main reason for allowing the changing of dependencies would be to include
+    // dependencies that are required for the native project to build. For example,
+    // it does not need to include dependencies that are used in the JS-code only.
+    const defaultDependencies = createDependenciesMap(dependencies);
+    // NOTE: This is a hack to ensure this doesn't trigger an extraneous change in the `package.json`
+    // it isn't required for anything in the `ios` and `android` folders.
+    delete defaultDependencies["expo-status-bar"];
+    // NOTE: Expo splash screen is installed by default in the template but the config plugin also lives in prebuild-config
+    // so we can delete it to prevent an extraneous change in the `package.json`.
+    delete defaultDependencies["expo-splash-screen"];
+    const combinedDependencies = createDependenciesMap({
+        ...defaultDependencies,
+        ...pkg.dependencies
+    });
+    // These dependencies are only added, not overwritten from the project
+    const requiredDependencies = [
+        // TODO: This is no longer required because it's this same package.
+        "expo",
+        // TODO: Drop this somehow.
+        "react-native", 
+    ].filter((depKey)=>!!defaultDependencies[depKey]);
+    const symlinkedPackages = [];
+    const nonRecommendedPackages = [];
+    for (const dependenciesKey of requiredDependencies){
+        var ref;
+        // If the local package.json defined the dependency that we want to overwrite...
+        if ((ref = pkg.dependencies) == null ? void 0 : ref[dependenciesKey]) {
+            // Then ensure it isn't symlinked (i.e. the user has a custom version in their yarn workspace).
+            if ((0, _isModuleSymlinked.isModuleSymlinked)(projectRoot, {
+                moduleId: dependenciesKey,
+                isSilent: true
+            })) {
+                // If the package is in the project's package.json and it's symlinked, then skip overwriting it.
+                symlinkedPackages.push(dependenciesKey);
+                continue;
+            }
+            // Do not modify manually skipped dependencies
+            if (skipDependencyUpdate.includes(dependenciesKey)) {
+                continue;
+            }
+            // Warn users for outdated dependencies when prebuilding
+            const hasRecommendedVersion = versionRangesIntersect(pkg.dependencies[dependenciesKey], String(defaultDependencies[dependenciesKey]));
+            if (!hasRecommendedVersion) {
+                nonRecommendedPackages.push(`${dependenciesKey}@${defaultDependencies[dependenciesKey]}`);
+            }
+        }
+    }
+    if (symlinkedPackages.length) {
+        _log.log(`\u203A Using symlinked ${symlinkedPackages.map((pkg)=>_chalk().default.bold(pkg)).join(", ")} instead of recommended version(s).`);
+    }
+    if (nonRecommendedPackages.length) {
+        _log.warn(`\u203A Using current versions instead of recommended ${nonRecommendedPackages.map((pkg)=>_chalk().default.bold(pkg)).join(", ")}.`);
+    }
+    // Only change the dependencies if the normalized hash changes, this helps to reduce meaningless changes.
+    const hasNewDependencies = hashForDependencyMap(pkg.dependencies) !== hashForDependencyMap(combinedDependencies);
+    // Save the dependencies
+    let changedDependencies = [];
+    if (hasNewDependencies) {
+        var _dependencies;
+        changedDependencies = diffKeys(combinedDependencies, (_dependencies = pkg.dependencies) != null ? _dependencies : {}).sort();
+        var _dependencies1;
+        // Use Object.assign to preserve the original order of dependencies, this makes it easier to see what changed in the git diff.
+        pkg.dependencies = Object.assign((_dependencies1 = pkg.dependencies) != null ? _dependencies1 : {}, combinedDependencies);
+    }
+    return {
+        changedDependencies
+    };
+}
+function diffKeys(a, b) {
+    return Object.keys(a).filter((key)=>a[key] !== b[key]);
+}
+function createDependenciesMap(dependencies) {
+    if (typeof dependencies !== "object") {
+        throw new Error(`Dependency map is invalid, expected object but got ${typeof dependencies}`);
+    } else if (!dependencies) {
+        return {};
+    }
+    const outputMap = {};
+    for (const key of Object.keys(dependencies)){
+        const value = dependencies[key];
+        if (typeof value === "string") {
+            outputMap[key] = value;
+        } else {
+            throw new Error(`Dependency for key \`${key}\` should be a \`string\`, instead got: \`{ ${key}: ${JSON.stringify(value)} }\``);
+        }
+    }
+    return outputMap;
+}
+/**
+ * Update package.json scripts - `npm start` should default to `expo
+ * start --dev-client` rather than `expo start` after prebuilding, for example.
+ */ function updatePkgScripts({ pkg  }) {
+    var ref, ref1;
+    let hasChanged = false;
+    if (!pkg.scripts) {
+        pkg.scripts = {};
+    }
+    if (!((ref = pkg.scripts.android) == null ? void 0 : ref.includes("run"))) {
+        pkg.scripts.android = "expo run:android";
+        hasChanged = true;
+    }
+    if (!((ref1 = pkg.scripts.ios) == null ? void 0 : ref1.includes("run"))) {
+        pkg.scripts.ios = "expo run:ios";
+        hasChanged = true;
+    }
+    return hasChanged;
+}
+function normalizeDependencyMap(deps) {
+    return Object.keys(deps).map((dependency)=>`${dependency}@${deps[dependency]}`).sort();
+}
+function hashForDependencyMap(deps = {}) {
+    const depsList = normalizeDependencyMap(deps);
+    const depsString = depsList.join("\n");
+    return createFileHash(depsString);
+}
+function createFileHash(contents) {
+    // this doesn't need to be secure, the shorter the better.
+    return _crypto().default.createHash("sha1").update(contents).digest("hex");
+}
+/**
+ * Determine if two semver ranges are overlapping or intersecting.
+ * This is a safe version of `semver.intersects` that does not throw.
+ */ function versionRangesIntersect(rangeA, rangeB) {
+    try {
+        return (0, _semver().intersects)(rangeA, rangeB);
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=updatePackageJson.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/validateTemplatePlatforms.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateTemplatePlatforms", {
+    enumerable: true,
+    get: ()=>validateTemplatePlatforms
+});
+function _chalk() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
+    _chalk = function() {
+        return data;
+    };
+    return data;
+}
+function _path() {
+    const data = /*#__PURE__*/ _interopRequireDefault(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _log = /*#__PURE__*/ _interopRequireWildcard(require("../log"));
+const _dir = require("../utils/dir");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function validateTemplatePlatforms({ templateDirectory , platforms  }) {
+    const existingPlatforms = [];
+    for (const platform of platforms){
+        if ((0, _dir.directoryExistsSync)(_path().default.join(templateDirectory, platform))) {
+            existingPlatforms.push(platform);
+        } else {
+            _log.warn((0, _chalk().default)`⚠️  Skipping platform ${platform}. Use a template that contains native files for ${platform} (./${platform}).`);
+        }
+    }
+    return existingPlatforms;
+}
+
+//# sourceMappingURL=validateTemplatePlatforms.js.map

smart-app-city/frontend/node_modules/@expo/cli/build/src/prebuild/validateTemplatePlatforms.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/prebuild/validateTemplatePlatforms.ts"],"sourcesContent":["import { ModPlatform } from '@expo/config-plugins';\nimport chalk from 'chalk';\nimport path from 'path';\n\nimport * as Log from '../log';\nimport { directoryExistsSync } from '../utils/dir';\n\nexport function validateTemplatePlatforms({\n  templateDirectory,\n  platforms,\n}: {\n  templateDirectory: string;\n  platforms: ModPlatform[];\n}) {\n  const existingPlatforms: ModPlatform[] = [];\n\n  for (const platform of platforms) {\n    if (directoryExistsSync(path.join(templateDirectory, platform))) {\n      existingPlatforms.push(platform);\n    } else {\n      Log.warn(\n        chalk`⚠️  Skipping platform ${platform}. Use a template that contains native files for ${platform} (./${platform}).`\n      );\n    }\n  }\n\n  return existingPlatforms;\n}\n"],"names":["validateTemplatePlatforms","templateDirectory","platforms","existingPlatforms","platform","directoryExistsSync","path","join","push","Log","warn","chalk"],"mappings":"AAAA;;;;+BAOgBA,2BAAyB;;aAAzBA,yBAAyB;;;8DANvB,OAAO;;;;;;;8DACR,MAAM;;;;;;2DAEF,QAAQ;qBACO,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE3C,SAASA,yBAAyB,CAAC,EACxCC,iBAAiB,CAAA,EACjBC,SAAS,CAAA,EAIV,EAAE;IACD,MAAMC,iBAAiB,GAAkB,EAAE,AAAC;IAE5C,KAAK,MAAMC,QAAQ,IAAIF,SAAS,CAAE;QAChC,IAAIG,IAAAA,IAAmB,oBAAA,EAACC,KAAI,EAAA,QAAA,CAACC,IAAI,CAACN,iBAAiB,EAAEG,QAAQ,CAAC,CAAC,EAAE;YAC/DD,iBAAiB,CAACK,IAAI,CAACJ,QAAQ,CAAC,CAAC;QACnC,OAAO;YACLK,IAAG,CAACC,IAAI,CACNC,IAAAA,MAAK,EAAA,QAAA,CAAA,CAAC,sBAAsB,EAAEP,QAAQ,CAAC,gDAAgD,EAAEA,QAAQ,CAAC,IAAI,EAAEA,QAAQ,CAAC,EAAE,CAAC,CACrH,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAOD,iBAAiB,CAAC;AAC3B,CAAC"}