NativeScript/nativescript-core/module-name-resolver/non-bundle-workflow-compat.ts

import * as fs from "../file-system/file-system";
import * as appCommonModule from "../application/application-common";
import {
    isEnabled as traceEnabled,
    write as traceWrite,
    categories as traceCategories
} from "../trace";

const cache = new Set<string>();
let initialized = false;

function register(name: string, loader: (name?: string) => void) {
    if (traceEnabled()) {
        traceWrite(`[Compat] Register module: ${name}`, traceCategories.ModuleNameResolver);
    }
    global.registerModule(name, loader);

    if (name.startsWith("tns_modules")) {
        const nonTnsModulesName = name.substr("tns_modules".length + 1);
        if (traceEnabled()) {
            traceWrite(`[Compat] Register module: ${nonTnsModulesName}`, traceCategories.ModuleNameResolver);
        }
        global.registerModule(nonTnsModulesName, loader);
    }
}

function processFile(file: fs.File) {
    const filePathRelativeToApp = file.path.substr(fs.knownFolders.currentApp().path.length + 1);
    const loadContent = () => file.readTextSync();

    switch (file.extension.toLocaleLowerCase()) {
        case ".js":
            const noExtPath = filePathRelativeToApp.substr(0, filePathRelativeToApp.length - ".js".length);

            register(filePathRelativeToApp, function () { return global.require(file.path); });
            register(noExtPath, function () { return global.require(file.path); });
            break;

        case ".css":
            register(filePathRelativeToApp, loadContent);
            break;

        case ".xml":
            register(filePathRelativeToApp, loadContent);
            break;
    }

    if (file.name === "package.json") {
        const json = global.require(file.path);
        if (json.main) {
            let name = filePathRelativeToApp.substr(0, filePathRelativeToApp.length - "package.json".length - 1);
            let requirePath = fs.path.join(file.parent.path, json.main);

            register(name, () => global.require(requirePath));
        }
    }
}

/**
 * Processes folder and returns true if folder was not empty.
 * @param Folder path
 */
function processFolder(path: string): boolean {
    if (cache.has(path)) {
        return true;
    }
    cache.add(path);

    if (traceEnabled()) {
        traceWrite(`[Compat] Processing folder: ${path}`, traceCategories.ModuleNameResolver);
    }

    let folderEmpty = true;

    if (fs.Folder.exists(path)) {
        const folder = fs.Folder.fromPath(path);

        folder.eachEntity((file) => {
            if (file instanceof fs.File) {
                processFile(file);
                folderEmpty = false;
            }

            return true;
        });
    }

    return !folderEmpty;
}

/**
 * Registers loaders for all files from the containing folder with global.registerModule().
 * Compatibility method for non-webpack workflow (like in playground).
 * @param moduleName
 */
export function registerModulesFromFileSystem(moduleName: string) {
    initialize();

    let folderProcessed = false;
    let parentFolderProcessed = false;
    // moduleName is a folder with package.json
    const path = fs.path.join(fs.knownFolders.currentApp().path, moduleName);
    if (fs.Folder.exists(path)) {
        folderProcessed = processFolder(path);
    }

    // moduleName is file - load all files in its parent folder
    const parentName = moduleName.substr(0, moduleName.lastIndexOf(fs.path.separator));
    const parentFolderPath = fs.path.join(fs.knownFolders.currentApp().path, parentName);
    if (fs.Folder.exists(parentFolderPath)) {
        parentFolderProcessed = processFolder(parentFolderPath);
    }

    // Return only if we processed the actual folder or its parent folder.
    // If the parent folder is empty we should still check tns_modules
    // as this might be just a name of a plugin (ex. "nativescript-ui-autocomplete")
    if (folderProcessed || (parentFolderProcessed && parentName)) {
        return;
    }

    // moduleName is a folder in tns_modules ex. "nativescript-ui-chart"
    const tnsModulesPath = fs.path.join(fs.knownFolders.currentApp().path, "tns_modules", moduleName);
    if (fs.Folder.exists(tnsModulesPath)) {
        processFolder(tnsModulesPath);
    }

    // moduleName a file in tns_modules/plugin. Avoid traversing the whole tns_modules folder if parentName is empty
    if (parentName) {
        const tnsParentFolderPath = fs.path.join(fs.knownFolders.currentApp().path, "tns_modules", parentName);
        if (fs.Folder.exists(tnsParentFolderPath)) {
            processFolder(tnsParentFolderPath);
        }
    }
}

function initialize() {
    if (!initialized) {
        appCommonModule.on("livesync", args => cache.clear());
        initialized = true;
    }
}