TypeScript Context.makeModuleMap方法代码示例

    /**
     * Undefine a module
     * @param module Module to undefine.
     **/
    undef(id: string): void {
        const context = this.context;
        //Bind any waiting define() calls to this context,
        //fix for #408
        context.takeGlobalQueue();

        var map = context.makeModuleMap(id, this.relMap, true);
        var mod = getOwn(context.registry, id);

        mod.undefed = true;
        context.removeScript(id);

        delete context.defined[id];
        delete context.urlFetched[map.url];
        delete context.undefEvents[id];

        //Clean queued defines too. Go backwards
        //in array so that the splices do not
        //mess up the iteration.
        eachReverse(context.defQueue, (args, i) => {
            if (args[0] === id) {
                context.defQueue.splice(i, 1);
            }
        });
        delete context.defQueueMap[id];

        if (mod) {
            //Hold on to listeners in case the
            //module will be attempted to be reloaded
            //using a different config.
            if (mod.events.defined) {
                context.undefEvents[id] = mod.events;
            }

            context.cleanRegistry(id);
        }
    }

    require(deps:string|string[], callback?:Function, errback?: RequireJSContext.ActionRequireError): any {
        var id, map, requireMod;

        if (this.options.enableBuildCallback && callback && isFunction(callback)) {
            (callback as any).__requireJsBuild = true;
        }

        if (typeof deps === 'string') {
            if (isFunction(callback)) {
                //Invalid call
                return this.context.onError(makeError('requireargs', 'Invalid require call'), errback);
            }

            //If require|exports|module are requested, get the
            //value for them from the special handlers. Caveat:
            //this only works while module is being defined.
            if (this.relMap && hasProp(this.context.handlers, deps)) {
                return this.context.handlers[deps](this.context.registry[this.relMap.id]);
            }

            //TODO: req.get
            //Synchronous access to one module. If require.get is
            //available (as in the Node adapter), prefer that.
            // if (req.get) {
            //     return req.get(this.context, deps, relMap, localRequire);
            // }

            //Normalize module name, if it contains . or ..
            map = this.context.makeModuleMap(deps, this.relMap, false, true);
            id = map.id;

            if (!hasProp(this.context.defined, id)) {
                return this.context.onError(
                    makeError(
                        'notloaded',
                        'Module name "' + id +
                        '" has not been loaded yet for context: ' + this.context.contextName +
                        (this.relMap ? '' : '. Use require([])')));
            }
            return this.context.defined[id];
        }

        //Grab defines waiting in the global queue.
        this.context.intakeDefines();

        //Mark all the dependencies as needing to be loaded.
        nextTick(() => {
            //Some defines could have been added since the
            //require call, collect them.
            this.context.intakeDefines();

            requireMod = this.context.getModule(this.context.makeModuleMap(null, this.relMap));

            //Store if map config should be applied to this require
            //call for dependencies.
            requireMod.skipMap = this.options.skipMap;

            requireMod.init(deps, callback, errback, {
                enabled: true
            });

            this.context.checkLoaded();
        });

        return this.context.require;
    }

 specified(id: string): boolean {
     let relMapId = this.context.makeModuleMap(id, this.relMap, false, true).id;
     return (hasProp(this.context.defined, relMapId)
         || hasProp(this.context.registry, relMapId));
 }

 defined(id: string): boolean {
     let relMapId = this.context.makeModuleMap(id, this.relMap, false, true).id;
     return hasProp(this.context.defined, relMapId);
 }