Function parseJSObject

packages/core/src/generators/builder/generator.ts:464–539

(
  input: string,
)

 * @param input - The stringified object
 */
const parseJSObject = (
  input: string,
): {
  parsed: Record<string, string>;
  unparsed?: string;
} => {
  const unparsed: string[] = [];
  let parsed: Record<string, string> = {};

  try {
    const ast = parseExpression(`(${input})`, {
      plugins: ['jsx', 'typescript'],
      sourceType: 'module',
    });

    if (ast.type !== 'ObjectExpression') {
      return { parsed, unparsed: input };
    }

    for (const prop of ast.properties) {
      /**
       * If the object includes spread or method, we stop. We can't really break the component into Key/Value
       * and the whole expression is considered dynamic. We return `false` to signify that.
       */
      if (prop.type === 'ObjectMethod' || prop.type === 'SpreadElement') {
        if (!!prop.start && !!prop.end) {
          if (typeof input === 'string') {
            unparsed.push(input.slice(prop.start - 1, prop.end - 1));
          }
        }
        continue;
      }

      /**
       * Ignore shorthand objects when processing incomplete objects. Otherwise we may
       * create identifiers unintentionally.
       * Example: When accounting for shorthand objects, "{ color" would become
       * { color: color } thus creating a "color" identifier that does not exist.
       */
      if (prop.type === 'ObjectProperty') {
        if (prop.extra?.shorthand) {
          if (typeof input === 'string') {
            unparsed.push(input.slice(prop.start! - 1, prop.end! - 1));
          }
          continue;
        }

        let key = '';
        if (prop.key.type === 'Identifier') {
          key = prop.key.name;
        } else if (prop.key.type === 'StringLiteral') {
          key = prop.key.value;
        } else {
          continue;
        }

        if (typeof input === 'string') {
          const [val, err] = extractValue(input, prop.value);