silphius/app/astride/evaluators/object.js

export default function(node, {evaluate, scope}) {
  const {properties} = node;
  let isAsync = false;
  const entries = [];
  for (let i = 0; i < properties.length; i++) {
    if ('Property' === properties[i].type) {
      const {computed, key, value} = properties[i];
      let k;
      if (computed) {
        k = evaluate(key, {scope});
      }
      else if ('Identifier' === key.type) {
        k = {value: key.name};
      }
      else if ('Literal' === key.type) {
        k = {value: key.value};
      }
      /* v8 ignore next 3 */
      else {
        throw new Error(`property key type ${key.type} not implemented`);
      }
      const v = evaluate(value, {scope});
      isAsync ||= k.async || v.async;
      if (k.async || v.async) {
        entries.push(Promise.all([k.value, v.value]));
      }
      else {
        entries.push([k.value, v.value]);
      }
    }
    if ('SpreadElement' === properties[i].type) {
      const {argument} = properties[i];
      const spreading = evaluate(argument, {scope});
      isAsync ||= spreading.async;
      if (spreading.async) {
        entries.push(Promise.resolve(spreading.value).then((spreading) => {
          const entries = [];
          const keys = Object.keys(spreading);
          for (let i = 0; i < keys.length; ++i) {
            const key = keys[i];
            entries.push([key, spreading[key]]);
          }
          return entries;
        }));
      }
      else {
        const keys = Object.keys(spreading.value);
        for (let i = 0; i < keys.length; ++i) {
          const key = keys[i];
          entries.push([key, spreading.value[key]]);
        }
      }
    }
  }
  return {
    async: !!isAsync,
    value: isAsync
      ? Promise.all(entries)
        .then((entries) => {
          const flat = [];
          for (let i = 0; i < entries.length; ++i) {
            const entry = entries[i];
            if (Array.isArray(entry[0])) {
              for (let j = 0; j < entry.length; j++) {
                flat.push(entry[j]);
              }
            }
            else {
              flat.push(entry);
            }
          }
          return Object.fromEntries(flat);
        })
      : Object.fromEntries(entries),
  };
}