json-variables 11.0.2 → 11.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/CHANGELOG.md +0 -6
  2. package/LICENSE +1 -1
  3. package/dist/json-variables.esm.js +440 -371
  4. package/dist/json-variables.umd.js +26 -26
  5. package/package.json +46 -50
package/dist/json-variables.esm.js CHANGED
@@ -1,14 +1,14 @@
1
1
  /**
2
2
  * @name json-variables
3
3
  * @fileoverview Resolves custom-marked, cross-referenced paths in parsed JSON
4
- * @version 11.0.2
4
+ * @version 11.0.6
5
5
  * @author Roy Revelt, Codsen Ltd
6
6
  * @license MIT
7
7
  * {@link https://codsen.com/os/json-variables/}
8
8
  */
9
9
 
10
10
  import { traverse } from 'ast-monkey-traverse';
11
- import matcher from 'matcher';
11
+ import { isMatch } from 'matcher';
12
12
  import objectPath from 'object-path';
13
13
  import { arrayiffy } from 'arrayiffy-if-string';
14
14
  import { strFindHeadsTails } from 'string-find-heads-tails';
@@ -18,425 +18,494 @@ import { rApply } from 'ranges-apply';
18
18
  import { remDup } from 'string-remove-duplicate-heads-tails';
19
19
  import { matchRightIncl, matchLeftIncl } from 'string-match-left-right';
20
20
 
21
- var version$1 = "11.0.2";
21
+ var version$1 = "11.0.6";
22
22
 
23
23
  const version = version$1;
24
24
  const has = Object.prototype.hasOwnProperty;
25
25
  const defaults = {
26
- heads: "%%_",
27
- tails: "_%%",
28
- headsNoWrap: "%%-",
29
- tailsNoWrap: "-%%",
30
- lookForDataContainers: true,
31
- dataContainerIdentifierTails: "_data",
32
- wrapHeadsWith: "",
33
- wrapTailsWith: "",
34
- dontWrapVars: [],
35
- preventDoubleWrapping: true,
36
- wrapGlobalFlipSwitch: true,
37
- noSingleMarkers: false,
38
- resolveToBoolIfAnyValuesContainBool: true,
39
- resolveToFalseIfAnyValuesContainBool: true,
40
- throwWhenNonStringInsertedInString: false,
41
- allowUnresolved: false
26
+ heads: "%%_",
27
+ tails: "_%%",
28
+ headsNoWrap: "%%-",
29
+ tailsNoWrap: "-%%",
30
+ lookForDataContainers: true,
31
+ dataContainerIdentifierTails: "_data",
32
+ wrapHeadsWith: "",
33
+ wrapTailsWith: "",
34
+ dontWrapVars: [],
35
+ preventDoubleWrapping: true,
36
+ wrapGlobalFlipSwitch: true,
37
+ noSingleMarkers: false,
38
+ resolveToBoolIfAnyValuesContainBool: true,
39
+ resolveToFalseIfAnyValuesContainBool: true,
40
+ throwWhenNonStringInsertedInString: false,
41
+ allowUnresolved: false,
42
42
  };
43
43
  function isStr(something) {
44
- return typeof something === "string";
44
+ return typeof something === "string";
45
45
  }
46
46
  function isNum(something) {
47
- return typeof something === "number";
47
+ return typeof something === "number";
48
48
  }
49
49
  function isBool(something) {
50
- return typeof something === "boolean";
50
+ return typeof something === "boolean";
51
51
  }
52
52
  function isNull(something) {
53
- return something === null;
53
+ return something === null;
54
54
  }
55
55
  function isObj(something) {
56
- return something && typeof something === "object" && !Array.isArray(something);
56
+ return (something && typeof something === "object" && !Array.isArray(something));
57
57
  }
58
58
  function existy(x) {
59
- return x != null;
59
+ return x != null;
60
60
  }
61
61
  function trimIfString(something) {
62
- return isStr(something) ? something.trim() : something;
62
+ return isStr(something) ? something.trim() : something;
63
63
  }
64
64
  function getTopmostKey(str) {
65
- if (typeof str === "string" && str.length > 0 && str.indexOf(".") !== -1) {
66
- for (let i = 0, len = str.length; i < len; i++) {
67
- if (str[i] === ".") {
68
- return str.slice(0, i);
69
- }
70
- }
71
- }
72
- return str;
65
+ if (typeof str === "string" && str.length > 0 && str.indexOf(".") !== -1) {
66
+ for (let i = 0, len = str.length; i < len; i++) {
67
+ if (str[i] === ".") {
68
+ return str.slice(0, i);
69
+ }
70
+ }
71
+ }
72
+ return str;
73
73
  }
74
74
  function withoutTopmostKey(str) {
75
- if (typeof str === "string" && str.length > 0 && str.indexOf(".") !== -1) {
76
- for (let i = 0, len = str.length; i < len; i++) {
77
- if (str[i] === ".") {
78
- return str.slice(i + 1);
79
- }
80
- }
81
- }
82
- return str;
75
+ if (typeof str === "string" && str.length > 0 && str.indexOf(".") !== -1) {
76
+ for (let i = 0, len = str.length; i < len; i++) {
77
+ if (str[i] === ".") {
78
+ return str.slice(i + 1);
79
+ }
80
+ }
81
+ }
82
+ return str;
83
83
  }
84
84
  function goLevelUp(str) {
85
- if (typeof str === "string" && str.length > 0 && str.indexOf(".") !== -1) {
86
- for (let i = str.length; i--;) {
87
- if (str[i] === ".") {
88
- return str.slice(0, i);
89
- }
90
- }
91
- }
92
- return str;
85
+ if (typeof str === "string" && str.length > 0 && str.indexOf(".") !== -1) {
86
+ for (let i = str.length; i--;) {
87
+ if (str[i] === ".") {
88
+ return str.slice(0, i);
89
+ }
90
+ }
91
+ }
92
+ return str;
93
93
  }
94
94
  function getLastKey(str) {
95
- if (typeof str === "string" && str.length > 0 && str.indexOf(".") !== -1) {
96
- for (let i = str.length; i--;) {
97
- if (str[i] === ".") {
98
- return str.slice(i + 1);
99
- }
100
- }
101
- }
102
- return str;
95
+ if (typeof str === "string" && str.length > 0 && str.indexOf(".") !== -1) {
96
+ for (let i = str.length; i--;) {
97
+ if (str[i] === ".") {
98
+ return str.slice(i + 1);
99
+ }
100
+ }
101
+ }
102
+ return str;
103
103
  }
104
104
  function containsHeadsOrTails(str, opts) {
105
- if (typeof str !== "string" || !str.trim()) {
105
+ if (typeof str !== "string" || !str.trim()) {
106
+ return false;
107
+ }
108
+ if (str.includes(opts.heads) ||
109
+ str.includes(opts.tails) ||
110
+ (isStr(opts.headsNoWrap) &&
111
+ opts.headsNoWrap.length > 0 &&
112
+ str.includes(opts.headsNoWrap)) ||
113
+ (isStr(opts.tailsNoWrap) &&
114
+ opts.tailsNoWrap.length > 0 &&
115
+ str.includes(opts.tailsNoWrap))) {
116
+ return true;
117
+ }
106
118
  return false;
107
- }
108
- if (str.includes(opts.heads) || str.includes(opts.tails) || isStr(opts.headsNoWrap) && opts.headsNoWrap.length > 0 && str.includes(opts.headsNoWrap) || isStr(opts.tailsNoWrap) && opts.tailsNoWrap.length > 0 && str.includes(opts.tailsNoWrap)) {
109
- return true;
110
- }
111
- return false;
112
119
  }
113
120
  function removeWrappingHeadsAndTails(str, heads, tails) {
114
- let tempFrom;
115
- let tempTo;
116
- if (typeof str === "string" && str.length > 0 && matchRightIncl(str, 0, heads, {
117
- trimBeforeMatching: true,
118
- cb: (_c, _t, index) => {
119
- tempFrom = index;
120
- return true;
121
- }
122
- }) && matchLeftIncl(str, str.length - 1, tails, {
123
- trimBeforeMatching: true,
124
- cb: (_c, _t, index) => {
125
- tempTo = index + 1;
126
- return true;
127
- }
128
- })) {
129
- return str.slice(tempFrom, tempTo);
130
- }
131
- return str;
121
+ let tempFrom;
122
+ let tempTo;
123
+ if (typeof str === "string" &&
124
+ str.length > 0 &&
125
+ matchRightIncl(str, 0, heads, {
126
+ trimBeforeMatching: true,
127
+ cb: (_c, _t, index) => {
128
+ tempFrom = index;
129
+ return true;
130
+ },
131
+ }) &&
132
+ matchLeftIncl(str, str.length - 1, tails, {
133
+ trimBeforeMatching: true,
134
+ cb: (_c, _t, index) => {
135
+ tempTo = index + 1;
136
+ return true;
137
+ },
138
+ })) {
139
+ return str.slice(tempFrom, tempTo);
140
+ }
141
+ return str;
132
142
  }
133
143
  function wrap(placementValue, opts, dontWrapTheseVars = false, breadCrumbPath, newPath, oldVarName) {
134
- if (!opts.wrapHeadsWith) {
135
- opts.wrapHeadsWith = "";
136
- }
137
- if (!opts.wrapTailsWith) {
138
- opts.wrapTailsWith = "";
139
- }
140
- if (isStr(placementValue) && !dontWrapTheseVars && opts.wrapGlobalFlipSwitch && !opts.dontWrapVars.some(val => matcher.isMatch(oldVarName, val)) && (!opts.preventDoubleWrapping || opts.preventDoubleWrapping && isStr(placementValue) && !placementValue.includes(opts.wrapHeadsWith) && !placementValue.includes(opts.wrapTailsWith))) {
141
- return opts.wrapHeadsWith + placementValue + opts.wrapTailsWith;
142
- }
143
- if (dontWrapTheseVars) {
144
- if (!isStr(placementValue)) {
145
- return placementValue;
146
- }
147
- const tempValue = remDup(placementValue, {
148
- heads: opts.wrapHeadsWith,
149
- tails: opts.wrapTailsWith
150
- });
151
- if (!isStr(tempValue)) {
152
- return tempValue;
144
+ if (!opts.wrapHeadsWith) {
145
+ opts.wrapHeadsWith = "";
146
+ }
147
+ if (!opts.wrapTailsWith) {
148
+ opts.wrapTailsWith = "";
153
149
  }
154
- return removeWrappingHeadsAndTails(tempValue, opts.wrapHeadsWith, opts.wrapTailsWith);
155
- }
156
- return placementValue;
150
+ if (isStr(placementValue) &&
151
+ !dontWrapTheseVars &&
152
+ opts.wrapGlobalFlipSwitch &&
153
+ !opts.dontWrapVars.some((val) => isMatch(oldVarName, val)) &&
154
+ (!opts.preventDoubleWrapping ||
155
+ (opts.preventDoubleWrapping &&
156
+ isStr(placementValue) &&
157
+ !placementValue.includes(opts.wrapHeadsWith) &&
158
+ !placementValue.includes(opts.wrapTailsWith)))) {
159
+ return opts.wrapHeadsWith + placementValue + opts.wrapTailsWith;
160
+ }
161
+ if (dontWrapTheseVars) {
162
+ if (!isStr(placementValue)) {
163
+ return placementValue;
164
+ }
165
+ const tempValue = remDup(placementValue, {
166
+ heads: opts.wrapHeadsWith,
167
+ tails: opts.wrapTailsWith,
168
+ });
169
+ if (!isStr(tempValue)) {
170
+ return tempValue;
171
+ }
172
+ return removeWrappingHeadsAndTails(tempValue, opts.wrapHeadsWith, opts.wrapTailsWith);
173
+ }
174
+ return placementValue;
157
175
  }
158
176
  function findValues(input, varName, path, opts) {
159
- let resolveValue;
160
- if (path.indexOf(".") !== -1) {
161
- let currentPath = path;
162
- let handBrakeOff = true;
163
- if (opts.lookForDataContainers && typeof opts.dataContainerIdentifierTails === "string" && opts.dataContainerIdentifierTails.length > 0 && !currentPath.endsWith(opts.dataContainerIdentifierTails)) {
164
- const gotPath = objectPath.get(input, currentPath + opts.dataContainerIdentifierTails);
165
- if (isObj(gotPath) && objectPath.get(gotPath, varName)) {
166
- resolveValue = objectPath.get(gotPath, varName);
167
- handBrakeOff = false;
168
- }
169
- }
170
- while (handBrakeOff && currentPath.indexOf(".") !== -1) {
171
- currentPath = goLevelUp(currentPath);
172
- if (getLastKey(currentPath) === varName) {
173
- throw new Error(`json-variables/findValues(): [THROW_ID_20] While trying to resolve: "${varName}" at path "${path}", we encountered a closed loop. The parent key "${getLastKey(currentPath)}" is called the same as the variable "${varName}" we're looking for.`);
174
- }
175
- if (opts.lookForDataContainers && typeof opts.dataContainerIdentifierTails === "string" && opts.dataContainerIdentifierTails.length > 0 && !currentPath.endsWith(opts.dataContainerIdentifierTails)) {
176
- const gotPath = objectPath.get(input, currentPath + opts.dataContainerIdentifierTails);
177
- if (isObj(gotPath) && objectPath.get(gotPath, varName)) {
178
- resolveValue = objectPath.get(gotPath, varName);
179
- handBrakeOff = false;
177
+ let resolveValue;
178
+ if (path.indexOf(".") !== -1) {
179
+ let currentPath = path;
180
+ let handBrakeOff = true;
181
+ if (opts.lookForDataContainers &&
182
+ typeof opts.dataContainerIdentifierTails === "string" &&
183
+ opts.dataContainerIdentifierTails.length > 0 &&
184
+ !currentPath.endsWith(opts.dataContainerIdentifierTails)) {
185
+ const gotPath = objectPath.get(input, currentPath + opts.dataContainerIdentifierTails);
186
+ if (isObj(gotPath) && objectPath.get(gotPath, varName)) {
187
+ resolveValue = objectPath.get(gotPath, varName);
188
+ handBrakeOff = false;
189
+ }
180
190
  }
181
- }
182
- if (resolveValue === undefined) {
183
- const gotPath = objectPath.get(input, currentPath);
184
- if (isObj(gotPath) && objectPath.get(gotPath, varName)) {
185
- resolveValue = objectPath.get(gotPath, varName);
186
- handBrakeOff = false;
191
+ while (handBrakeOff && currentPath.indexOf(".") !== -1) {
192
+ currentPath = goLevelUp(currentPath);
193
+ if (getLastKey(currentPath) === varName) {
194
+ throw new Error(`json-variables/findValues(): [THROW_ID_20] While trying to resolve: "${varName}" at path "${path}", we encountered a closed loop. The parent key "${getLastKey(currentPath)}" is called the same as the variable "${varName}" we're looking for.`);
195
+ }
196
+ if (opts.lookForDataContainers &&
197
+ typeof opts.dataContainerIdentifierTails === "string" &&
198
+ opts.dataContainerIdentifierTails.length > 0 &&
199
+ !currentPath.endsWith(opts.dataContainerIdentifierTails)) {
200
+ const gotPath = objectPath.get(input, currentPath + opts.dataContainerIdentifierTails);
201
+ if (isObj(gotPath) && objectPath.get(gotPath, varName)) {
202
+ resolveValue = objectPath.get(gotPath, varName);
203
+ handBrakeOff = false;
204
+ }
205
+ }
206
+ if (resolveValue === undefined) {
207
+ const gotPath = objectPath.get(input, currentPath);
208
+ if (isObj(gotPath) && objectPath.get(gotPath, varName)) {
209
+ resolveValue = objectPath.get(gotPath, varName);
210
+ handBrakeOff = false;
211
+ }
212
+ }
213
+ }
214
+ }
215
+ if (resolveValue === undefined) {
216
+ const gotPath = objectPath.get(input, varName);
217
+ if (gotPath !== undefined) {
218
+ resolveValue = gotPath;
187
219
  }
188
- }
189
- }
190
- }
191
- if (resolveValue === undefined) {
192
- const gotPath = objectPath.get(input, varName);
193
- if (gotPath !== undefined) {
194
- resolveValue = gotPath;
195
- }
196
- }
197
- if (resolveValue === undefined) {
198
- if (varName.indexOf(".") === -1) {
199
- const gotPathArr = getByKey(input, varName);
200
- if (gotPathArr.length > 0) {
201
- for (let y = 0, len2 = gotPathArr.length; y < len2; y++) {
202
- if (isStr(gotPathArr[y].val) || isBool(gotPathArr[y].val) || isNull(gotPathArr[y].val)) {
203
- resolveValue = gotPathArr[y].val;
204
- break;
205
- } else if (isNum(gotPathArr[y].val)) {
206
- resolveValue = String(gotPathArr[y].val);
207
- break;
208
- } else if (Array.isArray(gotPathArr[y].val)) {
209
- resolveValue = gotPathArr[y].val.join("");
210
- break;
211
- } else {
212
- throw new Error(`json-variables/findValues(): [THROW_ID_21] While trying to resolve: "${varName}" at path "${path}", we actually found the key named ${varName}, but it was not equal to a string but to:\n${JSON.stringify(gotPathArr[y], null, 4)}\nWe can't resolve a string with that! It should be a string.`);
213
- }
220
+ }
221
+ if (resolveValue === undefined) {
222
+ if (varName.indexOf(".") === -1) {
223
+ const gotPathArr = getByKey(input, varName);
224
+ if (gotPathArr.length > 0) {
225
+ for (let y = 0, len2 = gotPathArr.length; y < len2; y++) {
226
+ if (isStr(gotPathArr[y].val) ||
227
+ isBool(gotPathArr[y].val) ||
228
+ isNull(gotPathArr[y].val)) {
229
+ resolveValue = gotPathArr[y].val;
230
+ break;
231
+ }
232
+ else if (isNum(gotPathArr[y].val)) {
233
+ resolveValue = String(gotPathArr[y].val);
234
+ break;
235
+ }
236
+ else if (Array.isArray(gotPathArr[y].val)) {
237
+ resolveValue = gotPathArr[y].val.join("");
238
+ break;
239
+ }
240
+ else {
241
+ throw new Error(`json-variables/findValues(): [THROW_ID_21] While trying to resolve: "${varName}" at path "${path}", we actually found the key named ${varName}, but it was not equal to a string but to:\n${JSON.stringify(gotPathArr[y], null, 4)}\nWe can't resolve a string with that! It should be a string.`);
242
+ }
243
+ }
244
+ }
214
245
  }
215
- }
216
- } else {
217
- const gotPath = getByKey(input, getTopmostKey(varName));
218
- if (gotPath.length > 0) {
219
- for (let y = 0, len2 = gotPath.length; y < len2; y++) {
220
- const temp = objectPath.get(gotPath[y].val, withoutTopmostKey(varName));
221
- if (temp && isStr(temp)) {
222
- resolveValue = temp;
223
- }
246
+ else {
247
+ const gotPath = getByKey(input, getTopmostKey(varName));
248
+ if (gotPath.length > 0) {
249
+ for (let y = 0, len2 = gotPath.length; y < len2; y++) {
250
+ const temp = objectPath.get(gotPath[y].val, withoutTopmostKey(varName));
251
+ if (temp && isStr(temp)) {
252
+ resolveValue = temp;
253
+ }
254
+ }
255
+ }
224
256
  }
225
- }
226
257
  }
227
- }
228
- return resolveValue;
258
+ return resolveValue;
229
259
  }
230
260
  function resolveString(input, string, path, opts, incomingBreadCrumbPath = []) {
231
- if (incomingBreadCrumbPath.includes(path)) {
232
- let extra = "";
233
- if (incomingBreadCrumbPath.length > 1) {
234
- const separator = " →\n";
235
- extra = incomingBreadCrumbPath.reduce((accum, curr, idx) => accum + (idx === 0 ? "" : separator) + (curr === path ? "💥 " : " ") + curr, " Here's the path we travelled up until we hit the recursion:\n\n");
236
- extra += `${separator}💥 ${path}`;
237
- }
238
- throw new Error(`json-variables/resolveString(): [THROW_ID_19] While trying to resolve: "${string}" at path "${path}", we encountered a closed loop, the key is referencing itself."${extra}`);
239
- }
240
- const secretResolvedVarsStash = {};
241
- const breadCrumbPath = Array.from(incomingBreadCrumbPath);
242
- breadCrumbPath.push(path);
243
- const finalRangesArr = new Ranges();
244
- function processHeadsAndTails(arr, dontWrapTheseVars, wholeValueIsVariable) {
245
- for (let i = 0, len = arr.length; i < len; i++) {
246
- const obj = arr[i];
247
- const varName = string.slice(obj.headsEndAt, obj.tailsStartAt);
248
- if (varName.length === 0) {
249
- finalRangesArr.push(obj.headsStartAt,
250
- obj.tailsEndAt
251
- );
252
- } else if (has.call(secretResolvedVarsStash, varName) && isStr(secretResolvedVarsStash[varName])) {
253
- finalRangesArr.push(obj.headsStartAt,
254
- obj.tailsEndAt,
255
- secretResolvedVarsStash[varName]
256
- );
257
- } else {
258
- let resolvedValue = findValues(input,
259
- varName.trim(),
260
- path,
261
- opts
262
- );
263
- if (resolvedValue === undefined) {
264
- if (opts.allowUnresolved === true) {
265
- resolvedValue = "";
266
- } else if (typeof opts.allowUnresolved === "string") {
267
- resolvedValue = opts.allowUnresolved;
268
- } else {
269
- throw new Error(`json-variables/processHeadsAndTails(): [THROW_ID_18] We couldn't find the value to resolve the variable ${string.slice(obj.headsEndAt, obj.tailsStartAt)}. We're at path: "${path}".`);
270
- }
271
- }
272
- if (!wholeValueIsVariable && opts.throwWhenNonStringInsertedInString && !isStr(resolvedValue)) {
273
- throw new Error(`json-variables/processHeadsAndTails(): [THROW_ID_23] While resolving the variable ${string.slice(obj.headsEndAt, obj.tailsStartAt)} at path ${path}, it resolved into a non-string value, ${JSON.stringify(resolvedValue, null, 4)}. This is happening because options setting "throwWhenNonStringInsertedInString" is active (set to "true").`);
261
+ if (incomingBreadCrumbPath.includes(path)) {
262
+ let extra = "";
263
+ if (incomingBreadCrumbPath.length > 1) {
264
+ const separator = " →\n";
265
+ extra = incomingBreadCrumbPath.reduce((accum, curr, idx) => accum +
266
+ (idx === 0 ? "" : separator) +
267
+ (curr === path ? "💥 " : " ") +
268
+ curr, " Here's the path we travelled up until we hit the recursion:\n\n");
269
+ extra += `${separator}💥 ${path}`;
274
270
  }
275
- if (isBool(resolvedValue)) {
276
- if (opts.resolveToBoolIfAnyValuesContainBool) {
277
- finalRangesArr.wipe();
278
- if (!opts.resolveToFalseIfAnyValuesContainBool) {
279
- return resolvedValue;
271
+ throw new Error(`json-variables/resolveString(): [THROW_ID_19] While trying to resolve: "${string}" at path "${path}", we encountered a closed loop, the key is referencing itself."${extra}`);
272
+ }
273
+ const secretResolvedVarsStash = {};
274
+ const breadCrumbPath = Array.from(incomingBreadCrumbPath);
275
+ breadCrumbPath.push(path);
276
+ const finalRangesArr = new Ranges();
277
+ function processHeadsAndTails(arr, dontWrapTheseVars, wholeValueIsVariable) {
278
+ for (let i = 0, len = arr.length; i < len; i++) {
279
+ const obj = arr[i];
280
+ const varName = string.slice(obj.headsEndAt, obj.tailsStartAt);
281
+ if (varName.length === 0) {
282
+ finalRangesArr.push(obj.headsStartAt,
283
+ obj.tailsEndAt
284
+ );
285
+ }
286
+ else if (has.call(secretResolvedVarsStash, varName) &&
287
+ isStr(secretResolvedVarsStash[varName])) {
288
+ finalRangesArr.push(obj.headsStartAt,
289
+ obj.tailsEndAt,
290
+ secretResolvedVarsStash[varName]
291
+ );
292
+ }
293
+ else {
294
+ let resolvedValue = findValues(input,
295
+ varName.trim(),
296
+ path,
297
+ opts
298
+ );
299
+ if (resolvedValue === undefined) {
300
+ if (opts.allowUnresolved === true) {
301
+ resolvedValue = "";
302
+ }
303
+ else if (typeof opts.allowUnresolved === "string") {
304
+ resolvedValue = opts.allowUnresolved;
305
+ }
306
+ else {
307
+ throw new Error(`json-variables/processHeadsAndTails(): [THROW_ID_18] We couldn't find the value to resolve the variable ${string.slice(obj.headsEndAt, obj.tailsStartAt)}. We're at path: "${path}".`);
308
+ }
309
+ }
310
+ if (!wholeValueIsVariable &&
311
+ opts.throwWhenNonStringInsertedInString &&
312
+ !isStr(resolvedValue)) {
313
+ throw new Error(`json-variables/processHeadsAndTails(): [THROW_ID_23] While resolving the variable ${string.slice(obj.headsEndAt, obj.tailsStartAt)} at path ${path}, it resolved into a non-string value, ${JSON.stringify(resolvedValue, null, 4)}. This is happening because options setting "throwWhenNonStringInsertedInString" is active (set to "true").`);
314
+ }
315
+ if (isBool(resolvedValue)) {
316
+ if (opts.resolveToBoolIfAnyValuesContainBool) {
317
+ finalRangesArr.wipe();
318
+ if (!opts.resolveToFalseIfAnyValuesContainBool) {
319
+ return resolvedValue;
320
+ }
321
+ return false;
322
+ }
323
+ resolvedValue = "";
324
+ }
325
+ else if (isNull(resolvedValue) && wholeValueIsVariable) {
326
+ finalRangesArr.wipe();
327
+ return resolvedValue;
328
+ }
329
+ else if (Array.isArray(resolvedValue)) {
330
+ resolvedValue = String(resolvedValue.join(""));
331
+ }
332
+ else if (isNull(resolvedValue)) {
333
+ resolvedValue = "";
334
+ }
335
+ else {
336
+ resolvedValue = String(resolvedValue);
337
+ }
338
+ const newPath = path.includes(".")
339
+ ? `${goLevelUp(path)}.${varName}`
340
+ : varName;
341
+ if (containsHeadsOrTails(resolvedValue, opts)) {
342
+ const replacementVal = wrap(resolveString(
343
+ input, resolvedValue, newPath, opts, breadCrumbPath), opts, dontWrapTheseVars, breadCrumbPath, newPath, varName.trim());
344
+ if (isStr(replacementVal)) {
345
+ finalRangesArr.push(obj.headsStartAt,
346
+ obj.tailsEndAt,
347
+ replacementVal);
348
+ }
349
+ }
350
+ else {
351
+ secretResolvedVarsStash[varName] = resolvedValue;
352
+ const replacementVal = wrap(resolvedValue, opts, dontWrapTheseVars, breadCrumbPath, newPath, varName.trim());
353
+ if (isStr(replacementVal)) {
354
+ finalRangesArr.push(obj.headsStartAt,
355
+ obj.tailsEndAt,
356
+ replacementVal);
357
+ }
358
+ }
280
359
  }
281
- return false;
282
- }
283
- resolvedValue = "";
284
- } else if (isNull(resolvedValue) && wholeValueIsVariable) {
285
- finalRangesArr.wipe();
286
- return resolvedValue;
287
- } else if (Array.isArray(resolvedValue)) {
288
- resolvedValue = String(resolvedValue.join(""));
289
- } else if (isNull(resolvedValue)) {
290
- resolvedValue = "";
291
- } else {
292
- resolvedValue = String(resolvedValue);
293
- }
294
- const newPath = path.includes(".") ? `${goLevelUp(path)}.${varName}` : varName;
295
- if (containsHeadsOrTails(resolvedValue, opts)) {
296
- const replacementVal = wrap(resolveString(
297
- input, resolvedValue, newPath, opts, breadCrumbPath), opts, dontWrapTheseVars, breadCrumbPath, newPath, varName.trim());
298
- if (isStr(replacementVal)) {
299
- finalRangesArr.push(obj.headsStartAt,
300
- obj.tailsEndAt,
301
- replacementVal);
302
- }
303
- } else {
304
- secretResolvedVarsStash[varName] = resolvedValue;
305
- const replacementVal = wrap(resolvedValue, opts, dontWrapTheseVars, breadCrumbPath, newPath, varName.trim());
306
- if (isStr(replacementVal)) {
307
- finalRangesArr.push(obj.headsStartAt,
308
- obj.tailsEndAt,
309
- replacementVal);
310
- }
311
360
  }
312
- }
313
- }
314
- return undefined;
315
- }
316
- let foundHeadsAndTails;
317
- try {
318
- foundHeadsAndTails = strFindHeadsTails(string, opts.heads, opts.tails, {
319
- source: "",
320
- throwWhenSomethingWrongIsDetected: false
321
- });
322
- } catch (error) {
323
- throw new Error(`json-variables/resolveString(): [THROW_ID_17] While trying to resolve string: "${string}" at path ${path}, something wrong with heads and tails was detected! Here's the internal error message:\n${error}`);
324
- }
325
- let wholeValueIsVariable = false;
326
- if (foundHeadsAndTails.length === 1 && rApply(string, [[foundHeadsAndTails[0].headsStartAt, foundHeadsAndTails[0].tailsEndAt]]).trim() === "") {
327
- wholeValueIsVariable = true;
328
- }
329
- const temp1 = processHeadsAndTails(foundHeadsAndTails, false, wholeValueIsVariable);
330
- if (isBool(temp1)) {
331
- return temp1;
332
- }
333
- if (isNull(temp1)) {
334
- return temp1;
335
- }
336
- try {
337
- foundHeadsAndTails = strFindHeadsTails(string, opts.headsNoWrap, opts.tailsNoWrap, {
338
- source: "",
339
- throwWhenSomethingWrongIsDetected: false
340
- });
341
- } catch (error) {
342
- throw new Error(`json-variables/resolveString(): [THROW_ID_22] While trying to resolve string: "${string}" at path ${path}, something wrong with no-wrap heads and no-wrap tails was detected! Here's the internal error message:\n${error}`);
343
- }
344
- if (foundHeadsAndTails.length === 1 && rApply(string, [[foundHeadsAndTails[0].headsStartAt, foundHeadsAndTails[0].tailsEndAt]]).trim() === "") {
345
- wholeValueIsVariable = true;
346
- }
347
- const temp2 = processHeadsAndTails(foundHeadsAndTails, true, wholeValueIsVariable);
348
- if (isBool(temp2)) {
349
- return temp2;
350
- }
351
- if (isNull(temp2)) {
352
- return temp2;
353
- }
354
- if (finalRangesArr && finalRangesArr.current()) {
355
- return rApply(string, finalRangesArr.current());
356
- }
357
- return string;
361
+ return undefined;
362
+ }
363
+ let foundHeadsAndTails;
364
+ try {
365
+ foundHeadsAndTails = strFindHeadsTails(string, opts.heads, opts.tails, {
366
+ source: "",
367
+ throwWhenSomethingWrongIsDetected: false,
368
+ });
369
+ }
370
+ catch (error) {
371
+ throw new Error(`json-variables/resolveString(): [THROW_ID_17] While trying to resolve string: "${string}" at path ${path}, something wrong with heads and tails was detected! Here's the internal error message:\n${error}`);
372
+ }
373
+ let wholeValueIsVariable = false;
374
+ if (foundHeadsAndTails.length === 1 &&
375
+ rApply(string, [
376
+ [foundHeadsAndTails[0].headsStartAt, foundHeadsAndTails[0].tailsEndAt],
377
+ ]).trim() === "") {
378
+ wholeValueIsVariable = true;
379
+ }
380
+ const temp1 = processHeadsAndTails(foundHeadsAndTails, false, wholeValueIsVariable);
381
+ if (isBool(temp1)) {
382
+ return temp1;
383
+ }
384
+ if (isNull(temp1)) {
385
+ return temp1;
386
+ }
387
+ try {
388
+ foundHeadsAndTails = strFindHeadsTails(string, opts.headsNoWrap, opts.tailsNoWrap, {
389
+ source: "",
390
+ throwWhenSomethingWrongIsDetected: false,
391
+ });
392
+ }
393
+ catch (error) {
394
+ throw new Error(`json-variables/resolveString(): [THROW_ID_22] While trying to resolve string: "${string}" at path ${path}, something wrong with no-wrap heads and no-wrap tails was detected! Here's the internal error message:\n${error}`);
395
+ }
396
+ if (foundHeadsAndTails.length === 1 &&
397
+ rApply(string, [
398
+ [foundHeadsAndTails[0].headsStartAt, foundHeadsAndTails[0].tailsEndAt],
399
+ ]).trim() === "") {
400
+ wholeValueIsVariable = true;
401
+ }
402
+ const temp2 = processHeadsAndTails(foundHeadsAndTails, true, wholeValueIsVariable);
403
+ if (isBool(temp2)) {
404
+ return temp2;
405
+ }
406
+ if (isNull(temp2)) {
407
+ return temp2;
408
+ }
409
+ if (finalRangesArr && finalRangesArr.current()) {
410
+ return rApply(string, finalRangesArr.current());
411
+ }
412
+ return string;
358
413
  }
359
414
  function jVar(input, originalOpts) {
360
- if (!arguments.length) {
361
- throw new Error("json-variables/jVar(): [THROW_ID_01] Alas! Inputs are missing!");
362
- }
363
- if (!isObj(input)) {
364
- throw new TypeError(`json-variables/jVar(): [THROW_ID_02] Alas! The input must be a plain object! Currently it's: ${Array.isArray(input) ? "array" : typeof input}`);
365
- }
366
- if (originalOpts && !isObj(originalOpts)) {
367
- throw new TypeError(`json-variables/jVar(): [THROW_ID_03] Alas! An Optional Options Object must be a plain object! Currently it's: ${Array.isArray(originalOpts) ? "array" : typeof originalOpts}`);
368
- }
369
- const opts = { ...defaults,
370
- ...originalOpts
371
- };
372
- if (!opts.dontWrapVars) {
373
- opts.dontWrapVars = [];
374
- } else if (!Array.isArray(opts.dontWrapVars)) {
375
- opts.dontWrapVars = arrayiffy(opts.dontWrapVars);
376
- }
377
- let culpritVal;
378
- let culpritIndex;
379
- if (opts.dontWrapVars.length > 0 && !opts.dontWrapVars.every((el, idx) => {
380
- if (!isStr(el)) {
381
- culpritVal = el;
382
- culpritIndex = idx;
383
- return false;
384
- }
385
- return true;
386
- })) {
387
- throw new Error(`json-variables/jVar(): [THROW_ID_05] Alas! All variable names set in opts.dontWrapVars should be of a string type. Computer detected a value "${culpritVal}" at index ${culpritIndex}, which is not string but ${Array.isArray(culpritVal) ? "array" : typeof culpritVal}!`);
388
- }
389
- if (opts.heads === "") {
390
- throw new Error("json-variables/jVar(): [THROW_ID_06] Alas! opts.heads are empty!");
391
- }
392
- if (opts.tails === "") {
393
- throw new Error("json-variables/jVar(): [THROW_ID_07] Alas! opts.tails are empty!");
394
- }
395
- if (opts.lookForDataContainers && opts.dataContainerIdentifierTails === "") {
396
- throw new Error("json-variables/jVar(): [THROW_ID_08] Alas! opts.dataContainerIdentifierTails is empty!");
397
- }
398
- if (opts.heads === opts.tails) {
399
- throw new Error("json-variables/jVar(): [THROW_ID_09] Alas! opts.heads and opts.tails can't be equal!");
400
- }
401
- if (opts.heads === opts.headsNoWrap) {
402
- throw new Error("json-variables/jVar(): [THROW_ID_10] Alas! opts.heads and opts.headsNoWrap can't be equal!");
403
- }
404
- if (opts.tails === opts.tailsNoWrap) {
405
- throw new Error("json-variables/jVar(): [THROW_ID_11] Alas! opts.tails and opts.tailsNoWrap can't be equal!");
406
- }
407
- if (opts.headsNoWrap === "") {
408
- throw new Error("json-variables/jVar(): [THROW_ID_12] Alas! opts.headsNoWrap is an empty string!");
409
- }
410
- if (opts.tailsNoWrap === "") {
411
- throw new Error("json-variables/jVar(): [THROW_ID_13] Alas! opts.tailsNoWrap is an empty string!");
412
- }
413
- if (opts.headsNoWrap === opts.tailsNoWrap) {
414
- throw new Error("json-variables/jVar(): [THROW_ID_14] Alas! opts.headsNoWrap and opts.tailsNoWrap can't be equal!");
415
- }
416
- let current;
417
- return traverse(input, (key, val, innerObj) => {
418
- if (existy(val) && containsHeadsOrTails(key, opts)) {
419
- throw new Error(`json-variables/jVar(): [THROW_ID_15] Alas! Object keys can't contain variables!\nPlease check the following key: ${key}`);
420
- }
421
- if (val !== undefined) {
422
- current = val;
423
- } else {
424
- current = key;
425
- }
426
- if (current === "") {
427
- return current;
428
- }
429
- if (opts.heads.length !== 0 && trimIfString(current) === trimIfString(opts.heads) || opts.tails.length !== 0 && trimIfString(current) === trimIfString(opts.tails) || opts.headsNoWrap.length !== 0 && trimIfString(current) === trimIfString(opts.headsNoWrap) || opts.tailsNoWrap.length !== 0 && trimIfString(current) === trimIfString(opts.tailsNoWrap)) {
430
- if (!opts.noSingleMarkers) {
431
- return current;
432
- }
433
- throw new Error(`json-variables/jVar(): [THROW_ID_16] Alas! While processing the input, we stumbled upon ${trimIfString(current)} which is equal to ${trimIfString(current) === trimIfString(opts.heads) ? "heads" : ""}${trimIfString(current) === trimIfString(opts.tails) ? "tails" : ""}${isStr(opts.headsNoWrap) && trimIfString(current) === trimIfString(opts.headsNoWrap) ? "headsNoWrap" : ""}${isStr(opts.tailsNoWrap) && trimIfString(current) === trimIfString(opts.tailsNoWrap) ? "tailsNoWrap" : ""}. If you wouldn't have set opts.noSingleMarkers to "true" this error would not happen and computer would have left the current element (${trimIfString(current)}) alone`);
415
+ if (!arguments.length) {
416
+ throw new Error("json-variables/jVar(): [THROW_ID_01] Alas! Inputs are missing!");
417
+ }
418
+ if (!isObj(input)) {
419
+ throw new TypeError(`json-variables/jVar(): [THROW_ID_02] Alas! The input must be a plain object! Currently it's: ${Array.isArray(input) ? "array" : typeof input}`);
420
+ }
421
+ if (originalOpts && !isObj(originalOpts)) {
422
+ throw new TypeError(`json-variables/jVar(): [THROW_ID_03] Alas! An Optional Options Object must be a plain object! Currently it's: ${Array.isArray(originalOpts) ? "array" : typeof originalOpts}`);
423
+ }
424
+ const opts = { ...defaults, ...originalOpts };
425
+ if (!opts.dontWrapVars) {
426
+ opts.dontWrapVars = [];
427
+ }
428
+ else if (!Array.isArray(opts.dontWrapVars)) {
429
+ opts.dontWrapVars = arrayiffy(opts.dontWrapVars);
430
+ }
431
+ let culpritVal;
432
+ let culpritIndex;
433
+ if (opts.dontWrapVars.length > 0 &&
434
+ !opts.dontWrapVars.every((el, idx) => {
435
+ if (!isStr(el)) {
436
+ culpritVal = el;
437
+ culpritIndex = idx;
438
+ return false;
439
+ }
440
+ return true;
441
+ })) {
442
+ throw new Error(`json-variables/jVar(): [THROW_ID_05] Alas! All variable names set in opts.dontWrapVars should be of a string type. Computer detected a value "${culpritVal}" at index ${culpritIndex}, which is not string but ${Array.isArray(culpritVal) ? "array" : typeof culpritVal}!`);
443
+ }
444
+ if (opts.heads === "") {
445
+ throw new Error("json-variables/jVar(): [THROW_ID_06] Alas! opts.heads are empty!");
446
+ }
447
+ if (opts.tails === "") {
448
+ throw new Error("json-variables/jVar(): [THROW_ID_07] Alas! opts.tails are empty!");
449
+ }
450
+ if (opts.lookForDataContainers && opts.dataContainerIdentifierTails === "") {
451
+ throw new Error("json-variables/jVar(): [THROW_ID_08] Alas! opts.dataContainerIdentifierTails is empty!");
452
+ }
453
+ if (opts.heads === opts.tails) {
454
+ throw new Error("json-variables/jVar(): [THROW_ID_09] Alas! opts.heads and opts.tails can't be equal!");
455
+ }
456
+ if (opts.heads === opts.headsNoWrap) {
457
+ throw new Error("json-variables/jVar(): [THROW_ID_10] Alas! opts.heads and opts.headsNoWrap can't be equal!");
458
+ }
459
+ if (opts.tails === opts.tailsNoWrap) {
460
+ throw new Error("json-variables/jVar(): [THROW_ID_11] Alas! opts.tails and opts.tailsNoWrap can't be equal!");
461
+ }
462
+ if (opts.headsNoWrap === "") {
463
+ throw new Error("json-variables/jVar(): [THROW_ID_12] Alas! opts.headsNoWrap is an empty string!");
464
+ }
465
+ if (opts.tailsNoWrap === "") {
466
+ throw new Error("json-variables/jVar(): [THROW_ID_13] Alas! opts.tailsNoWrap is an empty string!");
434
467
  }
435
- if (isStr(current) && containsHeadsOrTails(current, opts)) {
436
- return resolveString(input, current, innerObj.path, opts);
468
+ if (opts.headsNoWrap === opts.tailsNoWrap) {
469
+ throw new Error("json-variables/jVar(): [THROW_ID_14] Alas! opts.headsNoWrap and opts.tailsNoWrap can't be equal!");
437
470
  }
438
- return current;
439
- });
471
+ let current;
472
+ return traverse(input, (key, val, innerObj) => {
473
+ if (existy(val) && containsHeadsOrTails(key, opts)) {
474
+ throw new Error(`json-variables/jVar(): [THROW_ID_15] Alas! Object keys can't contain variables!\nPlease check the following key: ${key}`);
475
+ }
476
+ if (val !== undefined) {
477
+ current = val;
478
+ }
479
+ else {
480
+ current = key;
481
+ }
482
+ if (current === "") {
483
+ return current;
484
+ }
485
+ if ((opts.heads.length !== 0 &&
486
+ trimIfString(current) === trimIfString(opts.heads)) ||
487
+ (opts.tails.length !== 0 &&
488
+ trimIfString(current) === trimIfString(opts.tails)) ||
489
+ (opts.headsNoWrap.length !== 0 &&
490
+ trimIfString(current) === trimIfString(opts.headsNoWrap)) ||
491
+ (opts.tailsNoWrap.length !== 0 &&
492
+ trimIfString(current) === trimIfString(opts.tailsNoWrap))) {
493
+ if (!opts.noSingleMarkers) {
494
+ return current;
495
+ }
496
+ throw new Error(`json-variables/jVar(): [THROW_ID_16] Alas! While processing the input, we stumbled upon ${trimIfString(current)} which is equal to ${trimIfString(current) === trimIfString(opts.heads) ? "heads" : ""}${trimIfString(current) === trimIfString(opts.tails) ? "tails" : ""}${isStr(opts.headsNoWrap) &&
497
+ trimIfString(current) === trimIfString(opts.headsNoWrap)
498
+ ? "headsNoWrap"
499
+ : ""}${isStr(opts.tailsNoWrap) &&
500
+ trimIfString(current) === trimIfString(opts.tailsNoWrap)
501
+ ? "tailsNoWrap"
502
+ : ""}. If you wouldn't have set opts.noSingleMarkers to "true" this error would not happen and computer would have left the current element (${trimIfString(current)}) alone`);
503
+ }
504
+ if (isStr(current) && containsHeadsOrTails(current, opts)) {
505
+ return resolveString(input, current, innerObj.path, opts);
506
+ }
507
+ return current;
508
+ });
440
509
  }
441
510
 
442
511
  export { defaults, jVar, version };