Featured in core-spirits@wunderbyte.com
@param @optional {function} action
@param @optional {object} thisp
@returns {boolean} True when ready already (so false)
430047
function(action, thisp) {
			this.init(action, thisp);
			if(gui.debug) {
				console.warn('gui.ready() is for spirits, use gui.init()');
			}
			return false;
		}
931533
function(action, implementation){
            this.resolvableActions                      = this.resolvableActions                        || {};
            this.resolvableActions[action]              = this.resolvableActions[action]                || {};
            this.resolvableActions[action].actionName   = this.resolvableActions[action].actionName     || action;

            implementation = implementation || RL.ResolvableAction.Types[action];
            this.resolvableActions[action] = Object.create(implementation);
            // merge could be used instead of Object.create but is less desirable
            // RL.Util.merge(this.resolvableAction.Types[action], implementation);

            if(this.resolvableActions[action].init){
                this.resolvableActions[action].init.call(this);
            }
        }
1341773
function checkUrl() {
					if (new UriParameters(window.location.href).get("sap-ui-xx-asyncRouting") === "true") {
						Log.warning("Activation of async view loading in routing via url parameter is only temporarily supported and may be removed soon", "MobileTarget");
						return true;
					}
					return false;
				}
1291333
function sendAction(eventName, view, event) {
  let actionName = get(view, `attrs.${eventName}`) || get(view, eventName);
  let value = get(view, 'value');

  if (SEND_ACTION && typeof actionName === 'string') {
    let message = EMBER_GLIMMER_ANGLE_BRACKET_BUILT_INS
      ? `Passing actions to components as strings (like \`<Input @${eventName}="${actionName}" />\`) is deprecated. Please use closure actions instead (\`<Input @${eventName}={{action "${actionName}"}} />\`).`
      : `Passing actions to components as strings (like \`{{input ${eventName}="${actionName}"}}\`) is deprecated. Please use closure actions instead (\`{{input ${eventName}=(action "${actionName}")}}\`).`;

    deprecate(message, false, {
      id: 'ember-component.send-action',
      until: '4.0.0',
      url: 'https://emberjs.com/deprecations/v3.x#toc_ember-component-send-action',
    });

    view.triggerAction({
      action: actionName,
      actionContext: [value, event],
    });
  } else if (typeof actionName === 'function') {
    actionName(value, event);
  }

  if (actionName && !get(view, 'bubbles')) {
    event.stopPropagation();
  }
}
700359
def is_flag(action):
    
    action_types = [_StoreTrueAction, _StoreFalseAction, _StoreConstAction]
    return any(list(map(lambda Action: isinstance(action, Action), action_types)))
479522
function log(msg) {
        if (msg === void 0) { msg = ""; }
        return action(function (p) { console.log(msg); }).setType("log");
    }
115558
function(spirit) {
					var directive = gui.Crawler.CONTINUE;
					if (spirit.action.contains(type)) {
						spirit.action.$onaction(action);
						if (action.isConsumed) {
							directive = gui.Crawler.STOP;
							action.consumer = spirit;
						}
					}
					return directive;
				}
1253816
function(source, domap, thisp) {
		var result = {},
			mapping;
		this.each(source, function(key, value) {
			mapping = domap.call(thisp, key, value);
			if (mapping !== undefined) {
				result[key] = mapping;
			}
		});
		return result;
	}
569783
function _fillAction(entity, actionObj, actionType) {

    if (!(entity instanceof Scope) && !entity.id) {
      throw new Error('This entity does not have an ID.');
    }

    var ret = actionObj;

    if (Utils.isArray(actionObj)) {

      ret = actionObj.map(function (singleAction) {
        return _fillAction(entity, singleAction, actionType);
      });

    } else {
      ret.type = actionType !== 'all' && actionType ||  actionObj.type || '';
      _addEntityIdentifier(entity, ret);
    }

    return ret;
  }
565546
function(operation, thisp) {
		this._suspended = true;
		var res = operation.call(thisp);
		this._suspended = false;
		return res;
	}
1263484
function(action) {
			var list = this._trackedtypes[action.type];
			if (list) {
				list.forEach(function(checks) {
					var handler = checks[0];
					var matches = checks[1] === action.global;
					var hacking = handler === this.spirit && this.$handleownaction;
					if (matches && (handler !== action.target || hacking)) {
						handler.onaction(action);
					}
				}, this);
			}
		}
897736
function ( action ) {
			if (F.isOpen) {
				F.current.fitToView = $.type(action) === "boolean" ? action : !F.current.fitToView;

				// Help browser to restore document dimensions
				if (isTouch) {
					F.wrap.removeAttr('style').addClass('fancybox-tmp');

					F.trigger('onUpdate');
				}

				F.update();
			}
		}
1192878
function(name, action, context) {
        if (!name || !action) {
            return;
        }
        name = 'before' + name;
        return this.on(name, action, context);
    }
231105
function can (action, target) {
    return check(this.auth.credentials && this.auth.credentials.user, action, target)
  }
761680
function (e) {
			var mode, i;
			var keyModes = this._keyModes;
			for (i = keyModes.length - 1 ; i >= 0; i--) {
				mode = keyModes[i];
				if (typeof mode.match === "function") { //$NON-NLS-1$
					var actionID = mode.match(e);
					if (actionID !== undefined) {
						return this.invokeAction(actionID);
					}
				}
			}
			return false;
		}
1354568
function action(targetAction) {
    return function (target, propertyKey, descriptor) {
        if (targetAction == undefined) {
            var metadata = Reflect.getMetadata('design:paramtypes', target, propertyKey);
            if (metadata == undefined || metadata.length < 2)
                throw new Error('@action() must be applied to a function with two arguments. ' +
                    'eg: reducer(state: State, action: SubclassOfAction): State { }');
            targetAction = metadata[1];
        }
        var statexActions = {};
        if (Reflect.hasMetadata(constance_1.STATEX_ACTION_KEY, target)) {
            statexActions = Reflect.getMetadata(constance_1.STATEX_ACTION_KEY, target);
        }
        statexActions[propertyKey] = targetAction;
        Reflect.defineMetadata(constance_1.STATEX_ACTION_KEY, statexActions, target);
        return {
            value: function (state, payload) {
                return descriptor.value.call(this, state, payload);
            }
        };
    };
}
733237
function(name, action) {

        var handlers = this.__handlers__ || (this.__handlers__={});

        if (!action) {
            handlers[name] = [];
            return;
        }
        if (handlers[name]) {
            var hdls = handlers[name];
            var retains = [];
            for (var i = 0; i < hdls.length; i++) {
                if (action && hdls[i].action !== action) {
                    retains.push(hdls[i]);
                }
            }
            handlers[name] = retains;
        }

        return this;
    }