sports-miniapp/node_modules/licia/lazyImport.js

const stackTrace = require('./stackTrace');
const splitPath = require('./splitPath');
const startWith = require('./startWith');
const endWith = require('./endWith');
const defineProp = require('./defineProp');
const isStr = require('./isStr');
const has = require('./has');
const objToStr = require('./objToStr');
const unique = require('./unique');
const concat = require('./concat');
const keys = require('./keys');
const isArr = require('./isArr');
const toBool = require('./toBool');

const path = require('path');

exports = function(importFn, dirname) {
    return function(moduleId) {
        if (isRelative(moduleId)) {
            if (!dirname) {
                dirname = findDirName();
            }
            moduleId = path.join(dirname, moduleId);
        }

        const { cache } = importFn;
        if (cache) {
            if (cache[moduleId]) {
                return importFn(moduleId);
            }
            if (!endWith(moduleId, '.js') && cache[`${moduleId}.js`]) {
                return importFn(`${moduleId}.js`);
            }
        }

        return proxyExports(importFn, moduleId);
    };
};

function proxyExports(importFn, moduleId) {
    const fakeExports = function() {};
    let cache;

    function doImport() {
        if (cache) {
            return;
        }
        const module = importFn(moduleId);
        cache = Object(module);

        const valueOfDescriptor = createDescriptor(0, 0, 1);
        if (isStr(module)) {
            valueOfDescriptor.value = () => String(module.valueOf());
        } else {
            valueOfDescriptor.value = () => Number(module.valueOf());
        }
        defineProp(cache, 'valueOf', valueOfDescriptor);

        defineProp(
            cache,
            'toString',
            createDescriptor(0, 0, 1, () => String(module.toString()))
        );

        if (!has(cache, Symbol.toStringTag)) {
            const realType = objToStr(module).slice(8, -1);
            Object.defineProperty(cache, Symbol.toStringTag, {
                configurable: true,
                get() {
                    return realType;
                }
            });
        }
    }

    return new Proxy(fakeExports, {
        get(target, property) {
            doImport();
            return cache[property];
        },
        set(target, property, value) {
            doImport();
            cache[property] = value;
            return true;
        },

        has(target, prop) {
            doImport();
            return prop in cache;
        },

        construct(target, argumentsList) {
            doImport();

            return new cache(...argumentsList);
        },

        apply(target, thisArg, argumentsList) {
            doImport();
            return cache.apply(thisArg, argumentsList);
        },

        ownKeys() {
            doImport();

            const descriptors = Object.getOwnPropertyDescriptors(cache);
            delete descriptors.valueOf;
            delete descriptors.toString;

            return unique(
                concat(
                    [
                        'arguments',
                        'caller',
                        'prototype',
                        'name',
                        'length',
                        Symbol.toStringTag
                    ],
                    keys(descriptors)
                )
            );
        },
        getOwnPropertyDescriptor(target, prop) {
            if (has(cache, prop)) {
                if (isArr(cache) && prop === 'length') {
                    return {
                        configurable: true,
                        enumerable: false,
                        writable: true
                    };
                } else {
                    const descriptor = Object.getOwnPropertyDescriptor(
                        cache,
                        prop
                    );
                    if (descriptor.configurable) {
                        return descriptor;
                    }
                    if (!fakeExports.prop) {
                        defineProp(fakeExports, prop, descriptor);
                    }
                    return descriptor;
                }
            } else {
                switch (prop) {
                    case 'arguments':
                        return createDescriptor(0, 0, 0, null);
                    case 'caller':
                        return createDescriptor(0, 0, 0, null);
                    case 'prototype':
                        return createDescriptor(0, 0, 1, null);
                    case 'length':
                        return createDescriptor(1, 0, 0, 0);
                    case 'name':
                        return createDescriptor(1, 0, 0, '');
                    default:
                        return {
                            configurable: true,
                            enumerable: true,
                            writable: true
                        };
                }
            }
        }
    });
}

function createDescriptor(configurable, enumerable, writable, value) {
    return {
        configurable: toBool(configurable),
        enumerable: toBool(enumerable),
        writable: toBool(writable),
        value
    };
}

function findDirName() {
    const stack = stackTrace();
    for (const item of stack) {
        const fileName = item.getFileName();
        if (fileName !== module.filename) {
            return splitPath(fileName).dir;
        }
    }

    return '';
}

function isRelative(moduleId) {
    return startWith(moduleId, './') || startWith(moduleId, '../');
}

module.exports = exports;