TypeScript Arguments.capture方法代码示例

  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));
    }
  };

  create(
    element: Simple.Element,
    _state: Opaque,
    args: Arguments,
    _dynamicScope: DynamicScope,
    dom: any
  ) {
    let { named, positional, tag } = args.capture();
    let implicitTarget;
    let actionName;
    let actionNameRef: any;
    if (positional.length > 1) {
      implicitTarget = positional.at(0);
      actionNameRef = positional.at(1);

      if (actionNameRef[INVOKE]) {
        actionName = actionNameRef;
      } else {
        let actionLabel = actionNameRef._propertyKey;
        actionName = actionNameRef.value();

        assert(
          'You specified a quoteless path, `' +
            actionLabel +
            '`, to the ' +
            '{{action}} helper which did not resolve to an action name (a ' +
            'string). Perhaps you meant to use a quoted actionName? (e.g. ' +
            '{{action "' +
            actionLabel +
            '"}}).',
          typeof actionName === 'string' || typeof actionName === 'function'
        );
      }
    }

    let actionArgs: any[] = [];
    // The first two arguments are (1) `this` and (2) the action name.
    // Everything else is a param.
    for (let i = 2; i < positional.length; i++) {
      actionArgs.push(positional.at(i));
    }

    let actionId = uuid();
    return new ActionState(
      element,
      actionId,
      actionName,
      actionArgs,
      named,
      positional,
      implicitTarget,
      dom,
      tag
    );
  }

  prepareArgs(definition: CurlyComponentDefinition, args: Arguments): Option<PreparedArguments> {
    let componentPositionalParamsDefinition = definition.ComponentClass.class.positionalParams;

    if (DEBUG && componentPositionalParamsDefinition) {
      validatePositionalParameters(args.named, args.positional, componentPositionalParamsDefinition);
    }

    let componentHasRestStylePositionalParams = typeof componentPositionalParamsDefinition === 'string';
    let componentHasPositionalParams = componentHasRestStylePositionalParams ||
                                       componentPositionalParamsDefinition.length > 0;
    let needsPositionalParamMunging = componentHasPositionalParams && args.positional.length !== 0;
    let isClosureComponent = definition.args;

    if (!needsPositionalParamMunging && !isClosureComponent) {
      return null;
    }

    let capturedArgs = args.capture();
    // grab raw positional references array
    let positional = capturedArgs.positional.references;

    // handle prep for closure component with positional params
    let curriedNamed;
    if (definition.args) {
      let remainingDefinitionPositionals = definition.args.positional.slice(positional.length);
      positional = positional.concat(remainingDefinitionPositionals);
      curriedNamed = definition.args.named;
    }

    // handle positionalParams
    let positionalParamsToNamed;
    if (componentHasRestStylePositionalParams) {
      positionalParamsToNamed = {
        [componentPositionalParamsDefinition]: new PositionalArgumentReference(positional),
      };
      positional = [];
    } else if (componentHasPositionalParams) {
      positionalParamsToNamed = {};
      let length = Math.min(positional.length, componentPositionalParamsDefinition.length);
      for (let i = 0; i < length; i++) {
        let name = componentPositionalParamsDefinition[i];
        positionalParamsToNamed[name] = positional[i];
      }
    }

    let named = assign({}, curriedNamed, positionalParamsToNamed, capturedArgs.named.map);

    return { positional, named };
  }

export default function(_vm: VM, args: Arguments) {
  return new InternalHelperReference(concat, args.capture());
}

export default function(_vm: VM, args: Arguments) {
  return new InternalHelperReference(normalizeClass, args.capture());
}

  create(
    element: Simple.Element,
    _state: Opaque,
    args: Arguments,
    _dynamicScope: DynamicScope,
    dom: any
  ) {
    let { named, positional, tag } = args.capture();
    let implicitTarget: any;
    let actionName;
    let actionNameRef: any;
    if (positional.length > 1) {
      implicitTarget = positional.at(0);
      actionNameRef = positional.at(1);

      if (actionNameRef[INVOKE]) {
        actionName = actionNameRef;
      } else {
        let actionLabel = actionNameRef._propertyKey;
        actionName = actionNameRef.value();

        assert(
          'You specified a quoteless path, `' +
            actionLabel +
            '`, to the ' +
            '{{action}} modifier which did not resolve to an action name (a ' +
            'string). Perhaps you meant to use a quoted actionName? (e.g. ' +
            '{{action "' +
            actionLabel +
            '"}}).',
          typeof actionName === 'string' || typeof actionName === 'function'
        );

        if (DEBUG && EMBER_NATIVE_DECORATOR_SUPPORT) {
          let implicitTargetValue = implicitTarget.value();

          warn(
            `You passed a method, ${actionLabel}, to the {{action}} modifier which was not decorated with the '@action' decorator. All actions should be decorated with the '@action' decorator.`,
            typeof actionName !== 'function' ||
              !implicitTargetValue ||
              implicitTargetValue[actionLabel] !== actionName ||
              actionName[ACTION_METHOD] === true,
            {
              id: 'action-without-decorator',
            }
          );
        }
      }
    }

    let actionArgs: any[] = [];
    // The first two arguments are (1) `this` and (2) the action name.
    // Everything else is a param.
    for (let i = 2; i < positional.length; i++) {
      actionArgs.push(positional.at(i));
    }

    let actionId = uuid();
    return new ActionState(
      element,
      actionId,
      actionName,
      actionArgs,
      named,
      positional,
      implicitTarget,
      dom,
      tag
    );
  }