function inner_stringify()

in src/internal/qs/stringify.ts [63:223]

• 136 lines of code
• 48 McCabe index (conditional complexity)

function inner_stringify(
  object: any,
  prefix: PropertyKey,
  generateArrayPrefix: StringifyOptions['arrayFormat'] | ((prefix: string, key: string) => string),
  commaRoundTrip: boolean,
  allowEmptyArrays: boolean,
  strictNullHandling: boolean,
  skipNulls: boolean,
  encodeDotInKeys: boolean,
  encoder: StringifyOptions['encoder'],
  filter: StringifyOptions['filter'],
  sort: StringifyOptions['sort'],
  allowDots: StringifyOptions['allowDots'],
  serializeDate: StringifyOptions['serializeDate'],
  format: StringifyOptions['format'],
  formatter: StringifyOptions['formatter'],
  encodeValuesOnly: boolean,
  charset: StringifyOptions['charset'],
  sideChannel: WeakMap<any, any>,
) {
  let obj = object;

  let tmp_sc = sideChannel;
  let step = 0;
  let find_flag = false;
  while ((tmp_sc = tmp_sc.get(sentinel)) !== void undefined && !find_flag) {
    // Where object last appeared in the ref tree
    const pos = tmp_sc.get(object);
    step += 1;
    if (typeof pos !== 'undefined') {
      if (pos === step) {
        throw new RangeError('Cyclic object value');
      } else {
        find_flag = true; // Break while
      }
    }
    if (typeof tmp_sc.get(sentinel) === 'undefined') {
      step = 0;
    }
  }

  if (typeof filter === 'function') {
    obj = filter(prefix, obj);
  } else if (obj instanceof Date) {
    obj = serializeDate?.(obj);
  } else if (generateArrayPrefix === 'comma' && is_array(obj)) {
    obj = maybe_map(obj, function (value) {
      if (value instanceof Date) {
        return serializeDate?.(value);
      }
      return value;
    });
  }

  if (obj === null) {
    if (strictNullHandling) {
      return encoder && !encodeValuesOnly ?
          // @ts-expect-error
          encoder(prefix, defaults.encoder, charset, 'key', format)
        : prefix;
    }

    obj = '';
  }

  if (is_non_nullish_primitive(obj) || is_buffer(obj)) {
    if (encoder) {
      const key_value =
        encodeValuesOnly ? prefix
          // @ts-expect-error
        : encoder(prefix, defaults.encoder, charset, 'key', format);
      return [
        formatter?.(key_value) +
          '=' +
          // @ts-expect-error
          formatter?.(encoder(obj, defaults.encoder, charset, 'value', format)),
      ];
    }
    return [formatter?.(prefix) + '=' + formatter?.(String(obj))];
  }

  const values: string[] = [];

  if (typeof obj === 'undefined') {
    return values;
  }

  let obj_keys;
  if (generateArrayPrefix === 'comma' && is_array(obj)) {
    // we need to join elements in
    if (encodeValuesOnly && encoder) {
      // @ts-expect-error values only
      obj = maybe_map(obj, encoder);
    }
    obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
  } else if (is_array(filter)) {
    obj_keys = filter;
  } else {
    const keys = Object.keys(obj);
    obj_keys = sort ? keys.sort(sort) : keys;
  }

  const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);

  const adjusted_prefix =
    commaRoundTrip && is_array(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;

  if (allowEmptyArrays && is_array(obj) && obj.length === 0) {
    return adjusted_prefix + '[]';
  }

  for (let j = 0; j < obj_keys.length; ++j) {
    const key = obj_keys[j];
    const value =
      // @ts-ignore
      typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key as any];

    if (skipNulls && value === null) {
      continue;
    }

    // @ts-ignore
    const encoded_key = allowDots && encodeDotInKeys ? (key as any).replace(/\./g, '%2E') : key;
    const key_prefix =
      is_array(obj) ?
        typeof generateArrayPrefix === 'function' ?
          generateArrayPrefix(adjusted_prefix, encoded_key)
        : adjusted_prefix
      : adjusted_prefix + (allowDots ? '.' + encoded_key : '[' + encoded_key + ']');

    sideChannel.set(object, step);
    const valueSideChannel = new WeakMap();
    valueSideChannel.set(sentinel, sideChannel);
    push_to_array(
      values,
      inner_stringify(
        value,
        key_prefix,
        generateArrayPrefix,
        commaRoundTrip,
        allowEmptyArrays,
        strictNullHandling,
        skipNulls,
        encodeDotInKeys,
        // @ts-ignore
        generateArrayPrefix === 'comma' && encodeValuesOnly && is_array(obj) ? null : encoder,
        filter,
        sort,
        allowDots,
        serializeDate,
        format,
        formatter,
        encodeValuesOnly,
        charset,
        valueSideChannel,
      ),
    );
  }

  return values;
}