@glimmer/runtime/dist/modules/es2017/lib/curried-value.js

Minimal runtime needed to render Glimmer templates

import { symbol, _WeakSet } from '@glimmer/util';
const TYPE = symbol('TYPE');
const INNER = symbol('INNER');
const OWNER = symbol('OWNER');
const ARGS = symbol('ARGS');
const RESOLVED = symbol('RESOLVED');
const CURRIED_VALUES = new _WeakSet();
export function isCurriedValue(value) {
  return CURRIED_VALUES.has(value);
}
export function isCurriedType(value, type) {
  return isCurriedValue(value) && value[TYPE] === type;
}
export class CurriedValue {
  /** @internal */
  constructor(type, inner, owner, args, resolved = false) {
    CURRIED_VALUES.add(this);
    this[TYPE] = type;
    this[INNER] = inner;
    this[OWNER] = owner;
    this[ARGS] = args;
    this[RESOLVED] = resolved;
  }

}
export function resolveCurriedValue(curriedValue) {
  let currentWrapper = curriedValue;
  let positional;
  let named;
  let definition, owner, resolved;

  while (true) {
    let {
      [ARGS]: curriedArgs,
      [INNER]: inner
    } = currentWrapper;

    if (curriedArgs !== null) {
      let {
        named: curriedNamed,
        positional: curriedPositional
      } = curriedArgs;

      if (curriedPositional.length > 0) {
        positional = positional === undefined ? curriedPositional : curriedPositional.concat(positional);
      }

      if (named === undefined) {
        named = [];
      }

      named.unshift(curriedNamed);
    }

    if (!isCurriedValue(inner)) {
      // Save off the owner that this helper was curried with. Later on,
      // we'll fetch the value of this register and set it as the owner on the
      // new root scope.
      definition = inner;
      owner = currentWrapper[OWNER];
      resolved = currentWrapper[RESOLVED];
      break;
    }

    currentWrapper = inner;
  }

  return {
    definition,
    owner,
    resolved,
    positional,
    named
  };
}
export function curry(type, spec, owner, args, resolved = false) {
  return new CurriedValue(type, spec, owner, args, resolved);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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