inject model method
@param {String} name
@param {Object} config
@param {String} m
162402
function injectModel(name, config, m) {
    const modelConfig = app.think.config('model', undefined, m);
    const cacheConfig = app.think.config('cache', undefined, m);
    config = helper.parseAdapterConfig(modelConfig, config);
    const instance = model(name, config, m);
    instance._cacheConfig = cacheConfig;
    return instance;
  }
1112190
function config(name) {
  const args = [].slice.call(arguments, 1)
  const modules = {
    ActionSheet: $actionSheet,
    Loading: $loading,
    Toast: $toast,
    Dialog: $dialog
  }
  const module = components[name] || modules[name]
  if (typeof module.config === 'function') {
    module.config.apply(null, args)
  }
  else {
    console.warn(`${name}.config is not a function`)
  }
}
1003850
function(config) {

        this.config = config;
        this.appContext = null;

        this.injectAppContext = this.config.injectAppContext === true ? true : false;

        //cache of loaded dependencies
        this.moduleMap = {};
    }
635362
function Mongo_model(name, schema) {
        if (!(schema instanceof mongoose.Schema)) {
            schema = this.schema(schema);
        }
        logger.info('Mongo.schema:', {
            name: name
        });
        return mongoose.model(name, schema);
    }
298122
function setModuleConfig(moduleConfig) {
                    if (!angular.isObject(moduleConfig)) {
                        throw new Error('You need to give the module config object to set');
                    }
                    modules[moduleConfig.name] = moduleConfig;
                    return moduleConfig;
                }
140745
function ComponentModel(key, impl, cfg) {
    this.key = key
    /**
     * @property {Any} impl The implementation to use for `resolve`
     * */
    this.impl =impl
    this._cfg = cfg || {}
    /**
     * @property {Array} inject The {String} dependencies array a service may declare
     * */
    this.inject = (this.impl.inject || [])
    /**
     * @property {String} initializable The method to invoke on an resolved service just after resolution, but before returning
     * injecting any dependencies found on that method
     * */
    this.initializable = (this.impl.initializable || false)
    /**
     * @property {String} startable The method to invoke on an resolved services when started. Usually during an app bootstrap.
     * */
    this.startable = (this.impl.startable || false)
}
70138
function addMethod(key) {
  Cacher.prototype[key] = function() {
    if (!this.md) {
      return Promise.reject(new Error('Model not set'));
    }
    this.method = key;
    return this.run.apply(this, arguments);
  };
}
882150
function initCreate (args) {
    // method name is moduleNameCreate
    var methodName = `${this.name}Create`
    // method signature is moduleName.methodname
    var methodSignature = `${this.moduleName}.${methodName}`
    // capture model to pass to function
    var model = this
    // add create method to module and to object instance
    this.createMeta = immutable.method(methodSignature, function (args) {
        return createMeta(model, args)
    }, {
        // disable freezing args
        freeze: false,
    })
}
1291701
public Object invokeMethod(String name, Object args) {
        try {
            return super.invokeMethod(name, args);
        }
        // if the method was not found in the current scope (the script's methods)
        // let's try to see if there's a method closure with the same name in the binding
        catch (MissingMethodException mme) {
            try {
                if (name.equals(mme.getMethod())) {
                    Object boundClosure = getProperty(name);
                    if (boundClosure != null && boundClosure instanceof Closure) {
                        return ((Closure) boundClosure).call((Object[])args);
                    } else {
                        throw mme;
                    }
                } else {
                    throw mme;
                }
            } catch (MissingPropertyException mpe) {
                throw mme;
            }
        }
    }
47699
function(name, config) {
            config = config || {};
            config = _.defaults(config, {
                loader: configs.resources.loader
            });
            config = _.extend(config, {
                namespace: name
            });
            Resources.namespaces[name] = config;
        }
20270
function __createSuper(config) {
    config = config || {};

    var _l = config.logger;
    if (!_l) {
        _l = console;
    }

    return function(methodName) {
        var self = this;

        var pp = this.__npm_mongoose_super_proto_proto;
        if (!pp) {
            pp = this.__proto__ || {};
            pp = pp.__proto__ || {};

            this.__npm_mongoose_super_proto_proto = pp;
        }

        var methodList  = this.__npm_mongoose_super_method_list || {};
        var method      = methodList[methodName];
        if (!method) {
            method = pp[methodName];
            if (!_u.func(method)) {
                return function() {

                    _l.error("mongoose-super::super", "Error : Parent model of " + _u.modelName(self) +
                            " has no method '" + methodName +"'");
                }
            }

            method = method.bind(this);
            methodList[methodName] = method;
            this.__npm_mongoose_super_method_list = methodList;
        }

        return method;
    };
}
269715
function(name){
      var config = this._wreqrHandlers[name];

      if (!config){
        throw new Error("Handler not found for '" + name + "'");
      }

      return function(){
        var args = Array.prototype.slice.apply(arguments);
        return config.callback.apply(config.context, args);
      };
    }
1213442
function (name) {
        if (JOII.Config.constructors.indexOf(name) !== -1) {
            return;
        }

        JOII.Config.constructors.push(name);
    }
86072
public BeanBox injectMethod(String methodName, Object... configs) {
		checkOrCreateMethodInjects();
		Class<?>[] paramTypes = new Class<?>[configs.length / 2];
		BeanBox[] params = new BeanBox[configs.length / 2];
		int mid = configs.length / 2;
		for (int i = 0; i < mid; i++)
			paramTypes[i] = (Class<?>) configs[i];
		for (int i = mid; i < configs.length; i++) {
			params[i - mid] = BeanBoxUtils.wrapParamToBox(configs[i]);
			params[i - mid].setType(paramTypes[i - mid]);
		}
		Method m = ReflectionUtils.findMethod(beanClass, methodName, paramTypes);
		if (m != null)
			ReflectionUtils.makeAccessible(m);
		this.getMethodInjects().put(m, params);
		return this;
	}
562371
function(config, name) {
            if (config && config !== Object(config)) {
                throw new Error('Config object should be a key/value object.');
            }

            var defaultConfig = {
                loop: false,
                maxLoops: Infinity
            };

            var instance = Object.create(Queue);

            this.queues.push(name ? {
                name: name,
                instance: instance
            } : {
                instance: instance
            });

            merge(instance, {
                config: merge({}, defaultConfig, config),
                steps: []
            });

            return instance;
        }
1136871
function initModule (args) {
    debug('new ImmutableCoreController', args)
    // require object for args
    assert.equal(typeof args, 'object', 'argument must be object')
    // get name from args if set
    if (args.name) {
        // require name to be string
        assert.equal(typeof args.name, 'string', 'name must be string')
        // set name
        this.name = args.name
    }
    else {
        // use model name if set
        if (args.model) {
            this.name = args.model.name
        }
        // require name
        else {
            throw new Error('name required')
        }
    }
    // set model
    this.model = args.model
    // module name is model name with Controller appended
    this.moduleName = this.name+'Controller'
    // create new immutable module for model - this will throw error
    // if moduleName is already defined
    this.module = immutable.module(this.moduleName, {})
    // add info to module meta
    this.module.meta.class = 'ImmutableCoreController'
    this.module.meta.instance = this
    // set default limit for index results
    this.defaultLimit = args.defaultLimit || DEFAULT_LIMIT
}
166072
function _ngModelWarning(name, type, instance, warningConfig) {
    if (!Object(_angular_core__WEBPACK_IMPORTED_MODULE_1__["isDevMode"])() || warningConfig === 'never')
        return;
    if (((warningConfig === null || warningConfig === 'once') && !type._ngModelWarningSentOnce) ||
        (warningConfig === 'always' && !instance._ngModelWarningSent)) {
        ReactiveErrors.ngModelWarning(name);
        type._ngModelWarningSentOnce = true;
        instance._ngModelWarningSent = true;
    }
}