···

       
1
       
1
       
+
       
---

     

       
2
       
2
       
+
       
'@urql/core': patch

     

       
3
       
3
       
+
       
---

     

       
4
       
4
       
+
       


     

       
5
       
5
       
+
       
Remove `for-of` syntax from `@urql/core` helpers for JSC memory reduction.

     

···

       
649
       
649
       
 
       
            } else {

     

       
650
       
650
       
 
       
              // If the current result has queued up an operation of the same

     

       
651
       
651
       
 
       
              // key, then `stale` refers to it

     

       
652
       
652
       
-
       
              for (const operation of queue) {

     

       
652
       
652
       
+
       
              for (let i = 0; i < queue.length; i++) {

     

       
653
       
653
       
+
       
                const operation = queue[i];

     

       
653
       
654
       
 
       
                if (operation.key === result.operation.key) {

     

       
654
       
655
       
 
       
                  dispatched.delete(operation.key);

     

       
655
       
656
       
 
       
                  break;

     

···

       
78
       
78
       
 
       
  }

     

       
79
       
79
       
 
       


     

       
80
       
80
       
 
       
  source.unshift(keyDocument(body));

     

       
81
       
81
       
-
       
  for (const document of source) {

     

       
82
       
82
       
-
       
    for (const definition of document.definitions) {

     

       
81
       
81
       
+
       
  for (let i = 0; i < source.length; i++) {

     

       
82
       
82
       
+
       
    for (let j = 0; j < source[i].definitions.length; j++) {

     

       
83
       
83
       
+
       
      const definition = source[i].definitions[j];

     

       
83
       
84
       
 
       
      if (definition.kind === Kind.FRAGMENT_DEFINITION) {

     

       
84
       
85
       
 
       
        const name = definition.name.value;

     

       
85
       
86
       
 
       
        const value = stringifyDocument(definition);

     

···

       
5
       
5
       
 
       


     

       
6
       
6
       
 
       
const collectTypes = (obj: EntityLike | EntityLike[], types: Set<string>) => {

     

       
7
       
7
       
 
       
  if (Array.isArray(obj)) {

     

       
8
       
8
       
-
       
    for (const item of obj) collectTypes(item, types);

     

       
8
       
8
       
+
       
    for (let i = 0, l = obj.length; i < l; i++) {

     

       
9
       
9
       
+
       
      collectTypes(obj[i], types);

     

       
10
       
10
       
+
       
    }

     

       
9
       
11
       
 
       
  } else if (typeof obj === 'object' && obj !== null) {

     

       
10
       
12
       
 
       
    for (const key in obj) {

     

       
11
       
13
       
 
       
      if (key === '__typename' && typeof obj[key] === 'string') {

     

···

       
8
       
8
       
 
       
  let error = '';

     

       
9
       
9
       
 
       
  if (networkErr) return `[Network] ${networkErr.message}`;

     

       
10
       
10
       
 
       
  if (graphQlErrs) {

     

       
11
       
11
       
-
       
    for (const err of graphQlErrs) {

     

       
11
       
11
       
+
       
    for (let i = 0, l = graphQlErrs.length; i < l; i++) {

     

       
12
       
12
       
 
       
      if (error) error += '\n';

     

       
13
       
13
       
-
       
      error += `[GraphQL] ${err.message}`;

     

       
13
       
13
       
+
       
      error += `[GraphQL] ${graphQlErrs[i].message}`;

     

       
14
       
14
       
 
       
    }

     

       
15
       
15
       
 
       
  }

     

       
16
       
16
       
 
       
  return error;

     

···

       
16
       
16
       
 
       
): FormattedNode<T> => {

     

       
17
       
17
       
 
       
  if ('definitions' in node) {

     

       
18
       
18
       
 
       
    const definitions: FormattedNode<DefinitionNode>[] = [];

     

       
19
       
19
       
-
       
    for (const definition of node.definitions) {

     

       
20
       
20
       
-
       
      const newDefinition = formatNode(definition);

     

       
19
       
19
       
+
       
    for (let i = 0, l = node.definitions.length; i < l; i++) {

     

       
20
       
20
       
+
       
      const newDefinition = formatNode(node.definitions[i]);

     

       
21
       
21
       
 
       
      definitions.push(newDefinition);

     

       
22
       
22
       
 
       
    }

     

       
23
       
23
       
 
       


     
···

       
27
       
27
       
 
       
  if ('directives' in node && node.directives && node.directives.length) {

     

       
28
       
28
       
 
       
    const directives: DirectiveNode[] = [];

     

       
29
       
29
       
 
       
    const _directives = {};

     

       
30
       
30
       
-
       
    for (const directive of node.directives) {

     

       
30
       
30
       
+
       
    for (let i = 0, l = node.directives.length; i < l; i++) {

     

       
31
       
31
       
+
       
      const directive = node.directives[i];

     

       
31
       
32
       
 
       
      let name = directive.name.value;

     

       
32
       
33
       
 
       
      if (name[0] !== '_') {

     

       
33
       
34
       
 
       
        directives.push(directive);

     
···

       
43
       
44
       
 
       
    const selections: FormattedNode<SelectionNode>[] = [];

     

       
44
       
45
       
 
       
    let hasTypename = node.kind === Kind.OPERATION_DEFINITION;

     

       
45
       
46
       
 
       
    if (node.selectionSet) {

     

       
46
       
46
       
-
       
      for (const selection of node.selectionSet.selections || []) {

     

       
47
       
47
       
+
       
      for (let i = 0, l = node.selectionSet.selections.length; i < l; i++) {

     

       
48
       
48
       
+
       
        const selection = node.selectionSet.selections[i];

     

       
47
       
49
       
 
       
        hasTypename =

     

       
48
       
50
       
 
       
          hasTypename ||

     

       
49
       
51
       
 
       
          (selection.kind === Kind.FIELD &&

     

···

       
180
       
180
       
 
       
 * @returns the operation's name contained within the document, or `undefined`

     

       
181
       
181
       
 
       
 */

     

       
182
       
182
       
 
       
export const getOperationName = (query: DocumentNode): string | undefined => {

     

       
183
       
183
       
-
       
  for (const node of query.definitions) {

     

       
183
       
183
       
+
       
  for (let i = 0, l = query.definitions.length; i < l; i++) {

     

       
184
       
184
       
+
       
    const node = query.definitions[i];

     

       
184
       
185
       
 
       
    if (node.kind === Kind.OPERATION_DEFINITION) {

     

       
185
       
186
       
 
       
      return node.name ? node.name.value : undefined;

     

       
186
       
187
       
 
       
    }

     
···

       
192
       
193
       
 
       
 * @returns the operation's type contained within the document, or `undefined`

     

       
193
       
194
       
 
       
 */

     

       
194
       
195
       
 
       
export const getOperationType = (query: DocumentNode): string | undefined => {

     

       
195
       
195
       
-
       
  for (const node of query.definitions) {

     

       
196
       
196
       
+
       
  for (let i = 0, l = query.definitions.length; i < l; i++) {

     

       
197
       
197
       
+
       
    const node = query.definitions[i];

     

       
196
       
198
       
 
       
    if (node.kind === Kind.OPERATION_DEFINITION) {

     

       
197
       
199
       
 
       
      return node.operation;

     

       
198
       
200
       
 
       
    }

     

···

       
53
       
53
       
 
       


     

       
54
       
54
       
 
       
const deepMerge = (target: any, source: any): any => {

     

       
55
       
55
       
 
       
  if (typeof target === 'object' && target != null) {

     

       
56
       
56
       
+
       
    if (Array.isArray(target)) {

     

       
57
       
57
       
+
       
      target = [...target];

     

       
58
       
58
       
+
       
      for (let i = 0, l = source.length; i < l; i++)

     

       
59
       
59
       
+
       
        target[i] = deepMerge(target[i], source[i]);

     

       
60
       
60
       
+
       
    }

     

       
56
       
61
       
 
       
    if (

     

       
57
       
62
       
 
       
      !target.constructor ||

     

       
58
       
63
       
 
       
      target.constructor === Object ||

     

       
59
       
64
       
 
       
      Array.isArray(target)

     

       
60
       
65
       
 
       
    ) {

     

       
61
       
61
       
-
       
      target = Array.isArray(target) ? [...target] : { ...target };

     

       
62
       
62
       
-
       
      for (const key of Object.keys(source))

     

       
66
       
66
       
+
       
      target = { ...target };

     

       
67
       
67
       
+
       
      for (const key in source)

     

       
63
       
68
       
 
       
        target[key] = deepMerge(target[key], source[key]);

     

       
64
       
69
       
 
       
      return target;

     

       
65
       
70
       
 
       
    }

     
···

       
108
       
113
       
 
       


     

       
109
       
114
       
 
       
  const withData = { data: prevResult.data };

     

       
110
       
115
       
 
       
  if (incremental) {

     

       
111
       
111
       
-
       
    for (const patch of incremental) {

     

       
116
       
116
       
+
       
    for (let i = 0, l = incremental.length; i < l; i++) {

     

       
117
       
117
       
+
       
      const patch = incremental[i];

     

       
112
       
118
       
 
       
      if (Array.isArray(patch.errors)) {

     

       
113
       
119
       
 
       
        errors.push(...(patch.errors as any));

     

       
114
       
120
       
 
       
      }

     

···

       
12
       
12
       
 
       
    return stringify(x.toJSON(), includeFiles);

     

       
13
       
13
       
 
       
  } else if (Array.isArray(x)) {

     

       
14
       
14
       
 
       
    let out = '[';

     

       
15
       
15
       
-
       
    for (const value of x) {

     

       
15
       
15
       
+
       
    for (let i = 0, l = x.length; i < l; i++) {

     

       
16
       
16
       
 
       
      if (out.length > 1) out += ',';

     

       
17
       
17
       
-
       
      out += stringify(value, includeFiles) || 'null';

     

       
17
       
17
       
+
       
      out += stringify(x[i], includeFiles) || 'null';

     

       
18
       
18
       
 
       
    }

     

       
19
       
19
       
 
       
    out += ']';

     

       
20
       
20
       
 
       
    return out;

     
···

       
39
       
39
       
 
       


     

       
40
       
40
       
 
       
  seen.add(x);

     

       
41
       
41
       
 
       
  let out = '{';

     

       
42
       
42
       
-
       
  for (const key of keys) {

     

       
43
       
43
       
-
       
    const value = stringify(x[key], includeFiles);

     

       
42
       
42
       
+
       
  for (let i = 0, l = keys.length; i < l; i++) {

     

       
43
       
43
       
+
       
    const value = stringify(x[keys[i]], includeFiles);

     

       
44
       
44
       
 
       
    if (value) {

     

       
45
       
45
       
 
       
      if (out.length > 1) out += ',';

     

       
46
       
46
       
-
       
      out += stringify(key, includeFiles) + ':' + value;

     

       
46
       
46
       
+
       
      out += stringify(keys[i], includeFiles) + ':' + value;

     

       
47
       
47
       
 
       
    }

     

       
48
       
48
       
 
       
  }

     

       
49
       
49
       
 
       


     
···

       
62
       
62
       
 
       
    map.set(path, x as File | Blob);

     

       
63
       
63
       
 
       
  } else {

     

       
64
       
64
       
 
       
    seen.add(x);

     

       
65
       
65
       
-
       
    for (const key of Object.keys(x)) extract(map, `${path}.${key}`, x[key]);

     

       
65
       
65
       
+
       
    for (const key in x) extract(map, `${path}.${key}`, x[key]);

     

       
66
       
66
       
 
       
  }

     

       
67
       
67
       
 
       
};

     

       
68
       
68