ember-source 7.1.0-alpha.5 → 7.2.0-alpha.1

package/dist/dev/packages/shared-chunks/curried-BVwSNqpf.js

@@ -1,628 +0,0 @@
-import { b as assertNever } from './assert-CUCJBR2C.js';
-
-const ANNOTATION_STYLES = ['background-color: oklch(93% 0.03 300); color: oklch(34% 0.18 300)', 'background-color: oklch(93% 0.03 250); color: oklch(34% 0.18 250)', 'background-color: oklch(93% 0.03 200); color: oklch(34% 0.18 200)', 'background-color: oklch(93% 0.03 150); color: oklch(34% 0.18 150)', 'background-color: oklch(93% 0.03 100); color: oklch(34% 0.18 100)', 'background-color: oklch(93% 0.03 50); color: oklch(34% 0.18 50)', 'background-color: oklch(93% 0.03 0); color: oklch(34% 0.18 0)'];
-
-/**
- * The `LogFragmentBuffer` is responsible for collecting the fragments that are logged to the
- * `DebugLogger` so that they can be accumulated during a group and flushed together.
- *
- * This queuing serves two purposes:
- *
- * 1. To allow the individual fragments that make up a single line to append their values to
- *    the current line. To accomplish this, each fragment can append static content and its
- *    formatting specifier (e.g. `%o`) to the accumulated {@link #template} *and* append the
- *    value to format to the {@link #substitutions} array.
- * 2. To allow logs that refer to objects to be represented as footnotes in the current line,
- *    with the footnote to be printed in a later line.
- *
- * This allows a list of fragments, each of which represent formattable values, to be flattened
- * into a single template string and an array of values to format.
- *
- * ## Footnotes
- *
- * An opcode slice containing constant references will be logged like this:
- *
- * ```
- * ...
- * 362. (PushArgs names=[] block-names=[] flags=16)
- * 366. (Helper helper=[0])
- * [0] glimmerHelper()
- * 368. (PopFrame)
- * 369. (Fetch register=$v0)
- * 371. (Primitive constant="/index.html")
- * ...
- * ```
- *
- * The fragment for line `366` includes an `ObjectFragment` for the helper value. When logged,
- * the object will be represented as a footnote and the value will be printed in a later
- * line.
- */
-class LogFragmentBuffer {
-  /**
-   * The first parameter to the `console.log` family of APIs is a *template* that can use
-   * format specifiers (e.g. `%c`, `%o`, and `%O`) to refer to subsequent parameters.
-   *
-   * When a fragment is appended to a line,
-   */
-  #template = '';
-
-  /**
-   * Each format specified in the {@link #template} corresponds to a value in the
-   * `#substitutions` array.
-   */
-  #substitutions = [];
-
-  /**
-   * The logging options for the buffer, which currently only contains `showSubtle`.
-   *
-   * When fragments call the buffer's {@linkcode append} method, they specify whether the
-   * content to append is subtle or not. If the buffer is not configured to show subtle
-   * content, the content is not appended.
-   *
-   * This allows fragments to append content to the buffer without having to know how the
-   * buffer is configured.
-   */
-  #options;
-
-  /**
-   * A single line can produce multiple queued log entries. This happens when fragments
-   * append *footnotes* to the buffer. A *reference* to the footnote is appended to the
-   * primary line, and a line containing the *value* of the footnote is appended to the
-   * `#queued` array.
-   *
-   * Both the primary line and any queued footnotes are flushed together when the buffer
-   * is flushed.
-   */
-  #footnotes = [];
-  #nextFootnote = 1;
-  #style = 0;
-  constructor(options) {
-    this.#options = options;
-  }
-
-  /**
-   * Add a footnoted value to the current buffer.
-   *
-   * If the `subtle` option is set, the fragment will only be printed if the buffer is configured
-   * to show subtle content.
-   *
-   * This method takes two callbacks: `add` and `append`.
-   *
-   * The `append` callback behaves like {@linkcode append}, but without the `subtle` argument. If
-   * `addFootnoted` is called with `subtle: false`, then the callback will never be called, so
-   * there is no need to pass the `subtle` argument again.
-   *
-   * The `add` callback is responsible for appending the footnote itself to the buffer. The first
-   * parameter to `add` (`useNumber`) specifies whether the caller has used the footnote number
-   * to refer to the footnote.
-   *
-   * This is typically true, but fragments can specify an alternative annotation that should be used
-   * instead of the default footnote number. In that case, the footnote number is not used, and the
-   * next footnote is free to use it.
-   *
-   * The `add` callback also takes a template string and an optional list of substitutions, which
-   * describe the way the footnote itself should be formatted.
-   */
-  addFootnoted(subtle, add) {
-    if (subtle && !this.#options.showSubtle) return;
-    const child = new LogFragmentBuffer(this.#options);
-    const style = ANNOTATION_STYLES[this.#style++ % ANNOTATION_STYLES.length];
-    const usedNumber = add({
-      n: this.#nextFootnote,
-      style
-    }, child);
-    if (usedNumber) {
-      this.#nextFootnote += 1;
-    }
-    this.#footnotes.push({
-      type: 'line',
-      subtle: false,
-      template: child.#template,
-      substitutions: child.#substitutions
-    });
-    this.#footnotes.push(...child.#footnotes);
-  }
-
-  /**
-   * Append a fragment to the current buffer.
-   *
-   * If the `subtle` option is set, the fragment will only be printed if the buffer is configured
-   * to show subtle content.
-   */
-  append(subtle, template, ...substitutions) {
-    if (subtle && !this.#options.showSubtle) return;
-    this.#template += template;
-    this.#substitutions.push(...substitutions);
-  }
-  #mapLine(line) {
-    if (line.subtle && !this.#options.showSubtle) return [];
-    return [{
-      type: 'line',
-      line: [line.template, ...line.substitutions]
-    }];
-  }
-  flush() {
-    return [{
-      type: 'line',
-      line: [this.#template, ...this.#substitutions]
-    }, ...this.#footnotes.flatMap(queued => this.#mapLine(queued))];
-  }
-}
-
-// inspired by https://github.com/ChromeDevTools/devtools-frontend/blob/c2c17396c9e0da3f1ce6514c3a946f88a06b17f2/front_end/ui/legacy/themeColors.css#L65
-const STYLES = {
-  var: 'color: grey',
-  varReference: 'color: blue; text-decoration: underline',
-  varBinding: 'color: blue;',
-  specialVar: 'color: blue',
-  prop: 'color: grey',
-  specialProp: 'color: red',
-  token: 'color: green',
-  def: 'color: blue',
-  builtin: 'color: blue',
-  punct: 'color: GrayText',
-  kw: 'color: rgb(185 0 99 / 100%);',
-  type: 'color: teal',
-  number: 'color: blue',
-  string: 'color: red',
-  null: 'color: grey',
-  specialString: 'color: darkred',
-  atom: 'color: blue',
-  attrName: 'color: orange',
-  attrValue: 'color: blue',
-  boolean: 'color: blue',
-  comment: 'color: green',
-  meta: 'color: grey',
-  register: 'color: purple',
-  constant: 'color: purple',
-  dim: 'color: grey',
-  internals: 'color: lightgrey; font-style: italic',
-  diffAdd: 'color: Highlight',
-  diffDelete: 'color: SelectedItemText; background-color: SelectedItem',
-  diffChange: 'color: MarkText; background-color: Mark',
-  sublabel: 'font-style: italic; color: grey',
-  error: 'color: red',
-  label: 'text-decoration: underline',
-  errorLabel: 'color: darkred; font-style: italic',
-  errorMessage: 'color: darkred; text-decoration: underline',
-  stack: 'color: grey; font-style: italic',
-  unbold: 'font-weight: normal',
-  pointer: 'background-color: lavender; color: indigo',
-  pointee: 'background-color: lavender; color: indigo',
-  focus: 'font-weight: bold',
-  focusColor: 'background-color: lightred; color: darkred'
-};
-function mergeStyle(a, b) {
-  if (a && b) {
-    return `${a}; ${b}`;
-  } else {
-    return a || b;
-  }
-}
-
-function intoFormat(format) {
-  if (typeof format === 'string') {
-    return {
-      style: STYLES[format]
-    };
-  } else {
-    return format;
-  }
-}
-function formats(...formats) {
-  return formats.map(c => intoFormat(c).style).join('; ');
-}
-
-const FORMATTERS = {
-  value: '%O',
-  string: '%s',
-  integer: '%d',
-  float: '%f',
-  special: '%o'
-};
-
-/**
- * A leaf fragment that represents an arbitrary value.
- *
- * When the value is a primitive, the fragment is appended to the buffer as if it was an instance of
- * the appropriate leaf fragment type (e.g. strings are appended as if they were `StringFragment`).
- *
- * Otherwise, `ValueFragment` is appended to the current line as a footnote reference and the value
- * itself is appended to a later line that *defines* the footnote using the `%O` format specifier.
- */
-
-/**
- * A leaf fragment that represents a string value.
- *
- * Corresponds to the `%s` format specifier.
- */
-
-/**
- * A leaf fragment that represents an integer value.
- *
- * Corresponds to the `%d` format specifier.
- */
-
-/**
- * A leaf fragment that represents a float value.
- *
- * Corresponds to the `%f` format specifier.
- */
-
-/**
- * A leaf fragment that represents a DOM node.
- *
- * Corresponds to the `%o` format specifier.
- */
-
-/**
- * The list of leaf fragment types correspond exactly to the list of console.log
- * format specifiers.
- */
-
-/**
- * @import { StyleName } from './styles';
- */
-
-/**
- * Fragment is the most fundamental building block of the debug logger.
- *
- */
-class Fragment {
-  static integer(value, options) {
-    return new Fragment({
-      kind: 'integer',
-      value,
-      ...options
-    });
-  }
-  static float(value, options) {
-    return new Fragment({
-      kind: 'float',
-      value,
-      ...options
-    });
-  }
-  static string(value, options) {
-    return new Fragment({
-      kind: 'string',
-      value,
-      ...options
-    });
-  }
-  static special(value, options) {
-    return new Fragment({
-      kind: 'special',
-      value,
-      ...options
-    });
-  }
-  #type;
-  constructor(type) {
-    this.#type = type;
-  }
-
-  /**
-   * A subtle fragment is only printed if the `showSubtle` option is set.
-   *
-   * Returns true if this fragment is a subtle leaf or is a multi fragment
-   * with all subtle leaves.
-   */
-  isSubtle() {
-    return this.leaves().every(leaf => leaf.#type.subtle);
-  }
-
-  /**
-   * If the current fragment is not empty, apply `ifPresent` to the current
-   * fragment. Otherwise, do nothing.
-   *
-   * If the current fragment is subtle, the result is also subtle.
-   */
-  map(ifPresent) {
-    if (this.isEmpty()) return this;
-    const fragment = ifPresent(this);
-    return this.isSubtle() ? fragment.subtle() : fragment;
-  }
-
-  /**
-   * A fragment is empty if it should not be printed with the provided display options.
-   *
-   * This means that if a fragment is subtle and `showSubtle` is false, the fragment is empty.
-   */
-  isEmpty(options = {
-    showSubtle: true
-  }) {
-    return this.leaves().every(leaf => !leaf.#shouldShow(options));
-  }
-
-  /**
-   * Returns an array of {@linkcode LeafFragment}s that make up the current
-   * fragment.
-   *
-   * This effectively flattens any number of nested multi-fragments into a flat array of leaf
-   * fragments.
-   */
-  leaves() {
-    if (this.#type.kind === 'multi') {
-      return this.#type.value.flatMap(f => f.leaves());
-    } else if (this.#type.kind === 'string' && this.#type.value === '') {
-      return [];
-    } else {
-      return [this];
-    }
-  }
-
-  /**
-   * Returns a fragment with the specified subtle status without mutating the current fragment.
-   *
-   * If `isSubtle` is true, the fragment will also be styled with the `subtle` style.
-   */
-  subtle(isSubtle = true) {
-    if (!this.isSubtle() && !isSubtle) {
-      return this;
-    }
-    const fragment = this.#subtle(isSubtle);
-    return isSubtle ? fragment.styleAll('dim') : fragment;
-  }
-  #subtle(isSubtle) {
-    if (this.#type.kind === 'multi') {
-      return new Fragment({
-        ...this.#type,
-        value: this.leaves().flatMap(f => f.subtle(isSubtle).leaves())
-      });
-    } else {
-      return new Fragment({
-        ...this.#type,
-        subtle: isSubtle
-      });
-    }
-  }
-
-  /**
-   * Apply the specified styles to the current fragment (if it's a leaf) or all
-   * of its children (if it's a multi-fragment).
-   *
-   * Keep in mind that merging styles might be very difficult to undo, so treat
-   * this as a low-level operation, and prefer to use higher-level concepts like
-   * `subtle` if you can instead.
-   */
-  styleAll(...allFormats) {
-    if (allFormats.length === 0) return this;
-    if (this.#type.kind === 'multi') {
-      return new Fragment({
-        ...this.#type,
-        value: this.#type.value.flatMap(f => f.styleAll(...allFormats).leaves())
-      });
-    } else {
-      return new Fragment({
-        ...this.#type,
-        style: mergeStyle(this.#type.style, formats(...allFormats))
-      });
-    }
-  }
-
-  /**
-   * Convert the current fragment into a string with no additional formatting.
-   * The primary purpose for this method is to support converting a fragment
-   * into a string for inclusion in thrown Errors. If you're going to *log*
-   * a fragment, log it using `DebugLogger` and don't convert it to
-   * a string first.
-   */
-  stringify(options) {
-    return this.leaves().filter(leaf => leaf.#shouldShow(options)).map(leaf => {
-      const fragment = leaf.#type;
-      if (fragment.kind === 'value') {
-        return `<object>`;
-      } else {
-        // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
-        return String(fragment.value);
-      }
-    }).join('');
-  }
-
-  /**
-   * Should the current fragment be printed with the provided display options?
-   *
-   * Importantly, if the current fragment contains subtle content but the `showSubtle` option is
-   * false, `#shouldShow` will return false.
-   *
-   * @see isEmpty
-   */
-  #shouldShow(options) {
-    return this.leaves().some(leaf => {
-      const fragment = leaf.#type;
-      if (fragment.subtle && !options.showSubtle) {
-        return false;
-      } else if (fragment.kind === 'string' && fragment.value === '') {
-        return false;
-      }
-      return true;
-    });
-  }
-
-  /**
-   * Convert this fragment into a Loggable for logging through the `DebugLogger`.
-   */
-  toLoggable(options) {
-    const buffer = new LogFragmentBuffer(options);
-    for (const leaf of this.leaves()) {
-      leaf.appendTo(buffer);
-    }
-    return buffer.flush();
-  }
-
-  /**
-   * Append this fragment to the low-level `LogFragmentBuffer`.
-   */
-  appendTo(buffer) {
-    const fragment = this.#type;
-    const subtle = this.isSubtle();
-
-    // If the fragment is a multi fragment, append each of its leaves to the buffer
-    // and return.
-    if (fragment.kind === 'multi') {
-      for (const f of fragment.value) {
-        f.appendTo(buffer);
-      }
-      return;
-    }
-
-    // If the fragment is a value fragment and the value is a primitive, give it special
-    // treatment since we can trivially serialize it.
-    if (fragment.kind === 'value') {
-      // If the value is a string or number, convert it into a string, float or integer
-      // fragment and append that instead. This means that strings and numbers are
-      // represented the same way in logs whether they are explicitly created as string,
-      // float or integer fragments *or* whether they are the value of a value fragment.
-      if (typeof fragment.value === 'string') {
-        return Fragment.string(JSON.stringify(fragment.value), {
-          style: STYLES.string,
-          subtle
-        }).appendTo(buffer);
-      } else if (typeof fragment.value === 'number') {
-        const f = fragment.value % 1 === 0 ? Fragment.integer : Fragment.float;
-        return f(fragment.value, {
-          style: STYLES.number,
-          subtle
-        }).appendTo(buffer);
-
-        // Alternatively, if the value of a `value` fragment is `null` or `undefined`,
-        // append the string `null` or `undefined`, respectively with the `null` style.
-      } else if (fragment.value === null || fragment.value === undefined) {
-        return Fragment.string('null', {
-          style: STYLES.null,
-          subtle: this.isSubtle()
-        }).appendTo(buffer);
-
-        // Finally, if the value of a `value` fragment is boolean, append the string
-        // `true` or `false` with the `boolean` style.
-      } else if (typeof fragment.value === 'boolean') {
-        return Fragment.string(String(fragment.value), {
-          style: STYLES.boolean,
-          subtle
-        }).appendTo(buffer);
-      }
-
-      // All other values (i.e. objects and functions) are represented as footnotes and
-      // are handled below.
-    }
-    switch (fragment.kind) {
-      // strings are appended using %s
-      case 'string':
-      // integers are appended using %d
-      case 'integer':
-      // floats are appended using %f
-      case 'float':
-        buffer.append(fragment.subtle ?? false, `%c${FORMATTERS[fragment.kind]}`, fragment.style, fragment.value);
-        break;
-      // the remaining value types are represented as footnotes
-      // dom nodes are appended to the footnote line using %o
-      case 'special':
-      // values are appended to the footnote line using %O
-      case 'value':
-        {
-          // If a fragment has an associated annotation, we'll use the annotation as the
-          // footnote rather than the footnote number.
-          const override = fragment.kind === 'value' ? fragment.display : undefined;
-          buffer.addFootnoted(fragment.subtle ?? false, ({
-            n,
-            style
-          }, footnote) => {
-            const appendValueAsFootnote = ref => void footnote.append(subtle, `%c| %c[${ref}]%c ${FORMATTERS[fragment.kind]}`, STYLES.dim, style, '', fragment.value);
-            if (override) {
-              if ('inline' in override) {
-                override.inline.subtle(subtle).appendTo(footnote);
-                return false;
-              }
-              buffer.append(subtle, `%c[${override.ref}]%c`, style, '');
-              if (override.footnote) {
-                frag`${as.dim('| ')}${override.footnote}`.subtle(subtle).appendTo(footnote);
-              } else {
-                appendValueAsFootnote(override.ref);
-              }
-              return false;
-            }
-            buffer.append(subtle, `%c[${n}]%c`, style, '');
-            appendValueAsFootnote(String(n));
-            return true;
-          });
-          break;
-        }
-      default:
-        assertNever(fragment);
-    }
-  }
-}
-function intoFragment(value) {
-  const fragments = intoFragments(value);
-  const [first, ...rest] = fragments;
-  if (first !== undefined && rest.length === 0) {
-    return first;
-  }
-  return new Fragment({
-    kind: 'multi',
-    value: fragments
-  });
-}
-function intoFragments(value) {
-  if (Array.isArray(value)) {
-    return value.flatMap(intoFragments);
-  } else if (typeof value === 'object' && value !== null) {
-    return value.leaves();
-  } else {
-    return [intoLeafFragment(value)];
-  }
-}
-function intoLeafFragment(value) {
-  if (value === null) {
-    return new Fragment({
-      kind: 'value',
-      value: null
-    });
-  } else if (typeof value === 'number') {
-    return new Fragment({
-      kind: 'integer',
-      value
-    });
-  } else if (typeof value === 'string') {
-    // If the string contains only whitespace and punctuation, we can treat it as a
-    // punctuation fragment.
-    if (/^[\s\p{P}\p{Sm}]*$/u.test(value)) {
-      return new Fragment({
-        kind: 'string',
-        value,
-        style: STYLES.punct
-      });
-    } else {
-      return new Fragment({
-        kind: 'string',
-        value
-      });
-    }
-  } else {
-    return value;
-  }
-}
-function frag(strings, ...values) {
-  const buffer = [];
-  strings.forEach((string, i) => {
-    buffer.push(...intoFragment(string).leaves());
-    const dynamic = values[i];
-    if (dynamic) {
-      buffer.push(...intoFragment(dynamic).leaves());
-    }
-  });
-  return new Fragment({
-    kind: 'multi',
-    value: buffer
-  });
-}
-const as = Object.fromEntries(Object.entries(STYLES).map(([k, v]) => [k, value => intoFragment(value).styleAll({
-  style: v
-})]));
-
-const CURRIED_COMPONENT = 0;
-const CURRIED_HELPER = 1;
-const CURRIED_MODIFIER = 2;
-
-export { CURRIED_MODIFIER as C, CURRIED_HELPER as a, CURRIED_COMPONENT as b };