TypeScript reference.isConst函数代码示例

//.........这里部分代码省略.........
  export default helper(disableBubbling);
  ```

  If you need the default handler to trigger you should either register your
  own event handler, or use event methods on your view class. See
  ["Responding to Browser Events"](/api/ember/release/classes/Component)
  in the documentation for `Component` for more information.

  ### Specifying DOM event type

  `{{action}}` helpers called in element space can specify an event type.
  By default the `{{action}}` helper registers for DOM `click` events. You can
  supply an `on` option to the helper to specify a different DOM event name:

  ```handlebars
  <div {{action "anActionName" on="doubleClick"}}>
    click me
  </div>
  ```

  See ["Event Names"](/api/ember/release/classes/Component) for a list of
  acceptable DOM event names.

  ### Specifying whitelisted modifier keys

  `{{action}}` helpers called in element space can specify modifier keys.
  By default the `{{action}}` helper will ignore click events with pressed modifier
  keys. You can supply an `allowedKeys` option to specify which keys should not be ignored.

  ```handlebars
  <div {{action "anActionName" allowedKeys="alt"}}>
    click me
  </div>
  ```

  This way the action will fire when clicking with the alt key pressed down.
  Alternatively, supply "any" to the `allowedKeys` option to accept any combination of modifier keys.

  ```handlebars
  <div {{action "anActionName" allowedKeys="any"}}>
    click me with any key pressed
  </div>
  ```

  ### Specifying a Target

  A `target` option can be provided to the helper to change
  which object will receive the method call. This option must be a path
  to an object, accessible in the current context:

  ```app/templates/application.hbs
  <div {{action "anActionName" target=someService}}>
    click me
  </div>
  ```

  ```app/controllers/application.js
  import Controller from '@ember/controller';
  import { inject as service } from '@ember/service';

  export default Controller.extend({
    someService: service()
  });
  ```

  @method action
  @for Ember.Templates.helpers
  @public
*/
export default function(_vm: VM, args: Arguments): UnboundReference<Function> {
  let { named, positional } = args;

  let capturedArgs = positional.capture();

  // The first two argument slots are reserved.
  // pos[0] is the context (or `this`)
  // pos[1] is the action name or function
  // Anything else is an action argument.
  let [context, action, ...restArgs] = capturedArgs.references;

  // TODO: Is there a better way of doing this?
  let debugKey: string | undefined = (action as any)._propertyKey;

  let target = named.has('target') ? named.get('target') : context;
  let processArgs = makeArgsProcessor(named.has('value') && named.get('value'), restArgs);

  let fn;

  if (typeof action[INVOKE] === 'function') {
    fn = makeClosureAction(action, action, action[INVOKE], processArgs, debugKey);
  } else if (isConst(target) && isConst(action)) {
    fn = makeClosureAction(context.value(), target.value(), action.value(), processArgs, debugKey);
  } else {
    fn = makeDynamicClosureAction(context.value(), target, action, processArgs, debugKey);
  }

  fn[ACTION] = true;

  return new UnboundReference(fn);
}

  renderHelper = function renderHelper(
    vm: VM,
    args: Arguments
  ): VersionedPathReference<CurriedComponentDefinition | null> {
    let env = vm.env as Environment;
    let nameRef = args.positional.at(0);

    assert(
      `The first argument of {{render}} must be quoted, e.g. {{render "sidebar"}}.`,
      isConst(nameRef)
    );
    // tslint:disable-next-line:max-line-length
    assert(
      `The second argument of {{render}} must be a path, e.g. {{render "post" post}}.`,
      args.positional.length === 1 || !isConst(args.positional.at(1))
    );

    let templateName = nameRef.value() as string;

    // tslint:disable-next-line:max-line-length
    assert(
      `You used \`{{render '${templateName}'}}\`, but '${templateName}' can not be found as a template.`,
      env.owner.hasRegistration(`template:${templateName}`)
    );

    let template = env.owner.lookup<OwnedTemplate>(`template:${templateName}`);

    let controllerName: string;

    if (args.named.has('controller')) {
      let controllerNameRef = args.named.get('controller');

      // tslint:disable-next-line:max-line-length
      assert(
        `The controller argument for {{render}} must be quoted, e.g. {{render "sidebar" controller="foo"}}.`,
        isConst(controllerNameRef)
      );

      // TODO should be ensuring this to string here
      controllerName = controllerNameRef.value() as string;

      // tslint:disable-next-line:max-line-length
      assert(
        `The controller name you supplied '${controllerName}' did not resolve to a controller.`,
        env.owner.hasRegistration(`controller:${controllerName}`)
      );
    } else {
      controllerName = templateName;
    }

    if (args.positional.length === 1) {
      let def = new RenderDefinition(controllerName, template, SINGLETON_RENDER_MANAGER);
      return UnboundReference.create(curry(def));
    } else {
      let def = new RenderDefinition(controllerName, template, NON_SINGLETON_RENDER_MANAGER);
      let captured = args.capture();
      return UnboundReference.create(curry(def, captured));
    }
  };

 static create(parentReference: VersionedPathReference<Opaque>, propertyKey: string) {
   if (isConst(parentReference)) {
     return new RootPropertyReference(parentReference.value(), propertyKey);
   } else {
     return new NestedPropertyReference(parentReference, propertyKey);
   }
 }

  static create(Helper: SimpleHelper, _vm: VM, args: CapturedArguments) {
    let helper = Helper.create();

    if (isConst(args)) {
      let { positional, named } = args;

      let positionalValue = positional.value();
      let namedValue = named.value();

      if (DEBUG) {
        maybeFreeze(positionalValue);
        maybeFreeze(namedValue);
      }

      let result = helper.compute(positionalValue, namedValue);

      if (typeof result === 'object' && result !== null || typeof result === 'function') {
        return new RootReference(result);
      } else {
        return PrimitiveReference.create(result);
      }
    } else {
      return new SimpleHelperReference(helper.compute, args);
    }
  }

 static create(sourceReference: VersionedPathReference<Opaque>, pathReference: PathReference<string>) {
   if (isConst(pathReference)) {
     let path = pathReference.value();
     return referenceFromPath(sourceReference, path);
   } else {
     return new GetHelperReference(sourceReference, pathReference);
   }
 }

 static create(_condRef: any, truthyRef: PrimitiveReference<boolean>, falsyRef: PrimitiveReference<boolean>) {
   let condRef = ConditionalReference.create(_condRef);
   if (isConst(condRef)) {
     return condRef.value() ? truthyRef : falsyRef;
   } else {
     return new ConditionalHelperReference(condRef, truthyRef, falsyRef);
   }
 }

 static create(sourceReference: any, pathReference: PathReference<any>) {
   if (isConst(pathReference)) {
     let parts = pathReference.value().split('.');
     return referenceFromParts(sourceReference, parts);
   } else {
     return new GetHelperReference(sourceReference, pathReference);
   }
 }