Skip to content

Commit d02b1d1

Browse files
sonnypsonnyp
committed
Add wip build script
1 parent 020cfec commit d02b1d1

11 files changed

Lines changed: 619 additions & 24 deletions

File tree

‎build-aux/wip/minimist.js‎

Lines changed: 308 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,308 @@
1+
/* eslint-disable */
2+
3+
// https://github.com/minimistjs/minimist/blob/bedaa8b9ab5a901fa342aad4494cbbf676b11a21/index.js
4+
5+
function hasKey(obj, keys) {
6+
var o = obj;
7+
keys.slice(0, -1).forEach(function (key) {
8+
o = o[key] || {};
9+
});
10+
11+
var key = keys[keys.length - 1];
12+
return key in o;
13+
}
14+
15+
function isNumber(x) {
16+
if (typeof x === "number") {
17+
return true;
18+
}
19+
if (/^0x[0-9a-f]+$/i.test(x)) {
20+
return true;
21+
}
22+
return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
23+
}
24+
25+
function isConstructorOrProto(obj, key) {
26+
return (
27+
(key === "constructor" && typeof obj[key] === "function") ||
28+
key === "__proto__"
29+
);
30+
}
31+
32+
export default function minimist(args, opts) {
33+
if (!opts) {
34+
opts = {};
35+
}
36+
37+
var flags = {
38+
bools: {},
39+
strings: {},
40+
unknownFn: null,
41+
};
42+
43+
if (typeof opts.unknown === "function") {
44+
flags.unknownFn = opts.unknown;
45+
}
46+
47+
if (typeof opts.boolean === "boolean" && opts.boolean) {
48+
flags.allBools = true;
49+
} else {
50+
[]
51+
.concat(opts.boolean)
52+
.filter(Boolean)
53+
.forEach(function (key) {
54+
flags.bools[key] = true;
55+
});
56+
}
57+
58+
var aliases = {};
59+
60+
function isBooleanKey(key) {
61+
if (flags.bools[key]) {
62+
return true;
63+
}
64+
if (!aliases[key]) {
65+
return false;
66+
}
67+
return aliases[key].some(function (x) {
68+
return flags.bools[x];
69+
});
70+
}
71+
72+
Object.keys(opts.alias || {}).forEach(function (key) {
73+
aliases[key] = [].concat(opts.alias[key]);
74+
aliases[key].forEach(function (x) {
75+
aliases[x] = [key].concat(
76+
aliases[key].filter(function (y) {
77+
return x !== y;
78+
}),
79+
);
80+
});
81+
});
82+
83+
[]
84+
.concat(opts.string)
85+
.filter(Boolean)
86+
.forEach(function (key) {
87+
flags.strings[key] = true;
88+
if (aliases[key]) {
89+
[].concat(aliases[key]).forEach(function (k) {
90+
flags.strings[k] = true;
91+
});
92+
}
93+
});
94+
95+
var defaults = opts.default || {};
96+
97+
var argv = { _: [] };
98+
99+
function argDefined(key, arg) {
100+
return (
101+
(flags.allBools && /^--[^=]+$/.test(arg)) ||
102+
flags.strings[key] ||
103+
flags.bools[key] ||
104+
aliases[key]
105+
);
106+
}
107+
108+
function setKey(obj, keys, value) {
109+
var o = obj;
110+
for (var i = 0; i < keys.length - 1; i++) {
111+
var key = keys[i];
112+
if (isConstructorOrProto(o, key)) {
113+
return;
114+
}
115+
if (o[key] === undefined) {
116+
o[key] = {};
117+
}
118+
if (
119+
o[key] === Object.prototype ||
120+
o[key] === Number.prototype ||
121+
o[key] === String.prototype
122+
) {
123+
o[key] = {};
124+
}
125+
if (o[key] === Array.prototype) {
126+
o[key] = [];
127+
}
128+
o = o[key];
129+
}
130+
131+
var lastKey = keys[keys.length - 1];
132+
if (isConstructorOrProto(o, lastKey)) {
133+
return;
134+
}
135+
if (
136+
o === Object.prototype ||
137+
o === Number.prototype ||
138+
o === String.prototype
139+
) {
140+
o = {};
141+
}
142+
if (o === Array.prototype) {
143+
o = [];
144+
}
145+
if (
146+
o[lastKey] === undefined ||
147+
isBooleanKey(lastKey) ||
148+
typeof o[lastKey] === "boolean"
149+
) {
150+
o[lastKey] = value;
151+
} else if (Array.isArray(o[lastKey])) {
152+
o[lastKey].push(value);
153+
} else {
154+
o[lastKey] = [o[lastKey], value];
155+
}
156+
}
157+
158+
function setArg(key, val, arg) {
159+
if (arg && flags.unknownFn && !argDefined(key, arg)) {
160+
if (flags.unknownFn(arg) === false) {
161+
return;
162+
}
163+
}
164+
165+
var value = !flags.strings[key] && isNumber(val) ? Number(val) : val;
166+
setKey(argv, key.split("."), value);
167+
168+
(aliases[key] || []).forEach(function (x) {
169+
setKey(argv, x.split("."), value);
170+
});
171+
}
172+
173+
// Set booleans to false by default.
174+
Object.keys(flags.bools).forEach(function (key) {
175+
setArg(key, false);
176+
});
177+
// Set booleans to user defined default if supplied.
178+
Object.keys(defaults)
179+
.filter(isBooleanKey)
180+
.forEach(function (key) {
181+
setArg(key, defaults[key]);
182+
});
183+
var notFlags = [];
184+
185+
if (args.indexOf("--") !== -1) {
186+
notFlags = args.slice(args.indexOf("--") + 1);
187+
args = args.slice(0, args.indexOf("--"));
188+
}
189+
190+
for (var i = 0; i < args.length; i++) {
191+
var arg = args[i];
192+
var key;
193+
var next;
194+
195+
if (/^--.+=/.test(arg)) {
196+
// Using [\s\S] instead of . because js doesn't support the
197+
// 'dotall' regex modifier. See:
198+
// http://stackoverflow.com/a/1068308/13216
199+
var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
200+
key = m[1];
201+
var value = m[2];
202+
if (isBooleanKey(key)) {
203+
value = value !== "false";
204+
}
205+
setArg(key, value, arg);
206+
} else if (/^--no-.+/.test(arg)) {
207+
key = arg.match(/^--no-(.+)/)[1];
208+
setArg(key, false, arg);
209+
} else if (/^--.+/.test(arg)) {
210+
key = arg.match(/^--(.+)/)[1];
211+
next = args[i + 1];
212+
if (
213+
next !== undefined &&
214+
!/^(-|--)[^-]/.test(next) &&
215+
!isBooleanKey(key) &&
216+
!flags.allBools
217+
) {
218+
setArg(key, next, arg);
219+
i += 1;
220+
} else if (/^(true|false)$/.test(next)) {
221+
setArg(key, next === "true", arg);
222+
i += 1;
223+
} else {
224+
setArg(key, flags.strings[key] ? "" : true, arg);
225+
}
226+
} else if (/^-[^-]+/.test(arg)) {
227+
var letters = arg.slice(1, -1).split("");
228+
229+
var broken = false;
230+
for (var j = 0; j < letters.length; j++) {
231+
next = arg.slice(j + 2);
232+
233+
if (next === "-") {
234+
setArg(letters[j], next, arg);
235+
continue;
236+
}
237+
238+
if (/[A-Za-z]/.test(letters[j]) && next[0] === "=") {
239+
setArg(letters[j], next.slice(1), arg);
240+
broken = true;
241+
break;
242+
}
243+
244+
if (
245+
/[A-Za-z]/.test(letters[j]) &&
246+
/-?\d+(\.\d*)?(e-?\d+)?$/.test(next)
247+
) {
248+
setArg(letters[j], next, arg);
249+
broken = true;
250+
break;
251+
}
252+
253+
if (letters[j + 1] && letters[j + 1].match(/\W/)) {
254+
setArg(letters[j], arg.slice(j + 2), arg);
255+
broken = true;
256+
break;
257+
} else {
258+
setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
259+
}
260+
}
261+
262+
key = arg.slice(-1)[0];
263+
if (!broken && key !== "-") {
264+
if (
265+
args[i + 1] &&
266+
!/^(-|--)[^-]/.test(args[i + 1]) &&
267+
!isBooleanKey(key)
268+
) {
269+
setArg(key, args[i + 1], arg);
270+
i += 1;
271+
} else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
272+
setArg(key, args[i + 1] === "true", arg);
273+
i += 1;
274+
} else {
275+
setArg(key, flags.strings[key] ? "" : true, arg);
276+
}
277+
}
278+
} else {
279+
if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
280+
argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
281+
}
282+
if (opts.stopEarly) {
283+
argv._.push.apply(argv._, args.slice(i + 1));
284+
break;
285+
}
286+
}
287+
}
288+
289+
Object.keys(defaults).forEach(function (k) {
290+
if (!hasKey(argv, k.split("."))) {
291+
setKey(argv, k.split("."), defaults[k]);
292+
293+
(aliases[k] || []).forEach(function (x) {
294+
setKey(argv, x.split("."), defaults[k]);
295+
});
296+
}
297+
});
298+
299+
if (opts["--"]) {
300+
argv["--"] = notFlags.slice();
301+
} else {
302+
notFlags.forEach(function (k) {
303+
argv._.push(k);
304+
});
305+
}
306+
307+
return argv;
308+
}

0 commit comments

Comments
 (0)