@tamagui/cli 1.89.26 → 1.89.27-1708113113238
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.
- package/dist/add.native.js +247 -58
- package/dist/add.native.js.map +3 -3
- package/dist/build.native.js +194 -29
- package/dist/build.native.js.map +3 -3
- package/dist/cli.native.js +438 -78
- package/dist/cli.native.js.map +3 -3
- package/dist/generate.native.js +250 -32
- package/dist/generate.native.js.map +3 -3
- package/dist/index.native.js.map +3 -3
- package/dist/studio.native.js +403 -91
- package/dist/studio.native.js.map +3 -3
- package/dist/update.native.js +127 -2
- package/dist/update.native.js.map +3 -3
- package/dist/utils.native.js +272 -53
- package/dist/utils.native.js.map +3 -3
- package/package.json +7 -7
package/dist/add.native.js
CHANGED
|
@@ -28,69 +28,258 @@ __export(add_exports, {
|
|
|
28
28
|
});
|
|
29
29
|
module.exports = __toCommonJS(add_exports);
|
|
30
30
|
var import_child_process = require("child_process"), import_fs = require("fs"), import_promises = require("fs/promises"), import_os = require("os"), import_path = __toESM(require("path")), import_chalk = __toESM(require("chalk")), import_change_case = require("change-case"), import_fs_extra = require("fs-extra"), import_marked = require("marked"), import_marked_terminal = __toESM(require("marked-terminal")), import_opener = __toESM(require("opener")), import_prompts = __toESM(require("prompts"));
|
|
31
|
+
function _array_like_to_array(arr, len) {
|
|
32
|
+
(len == null || len > arr.length) && (len = arr.length);
|
|
33
|
+
for (var i = 0, arr2 = new Array(len); i < len; i++)
|
|
34
|
+
arr2[i] = arr[i];
|
|
35
|
+
return arr2;
|
|
36
|
+
}
|
|
37
|
+
function _array_with_holes(arr) {
|
|
38
|
+
if (Array.isArray(arr))
|
|
39
|
+
return arr;
|
|
40
|
+
}
|
|
41
|
+
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
|
|
42
|
+
try {
|
|
43
|
+
var info = gen[key](arg), value = info.value;
|
|
44
|
+
} catch (error) {
|
|
45
|
+
reject(error);
|
|
46
|
+
return;
|
|
47
|
+
}
|
|
48
|
+
info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
|
|
49
|
+
}
|
|
50
|
+
function _async_to_generator(fn) {
|
|
51
|
+
return function() {
|
|
52
|
+
var self = this, args = arguments;
|
|
53
|
+
return new Promise(function(resolve, reject) {
|
|
54
|
+
var gen = fn.apply(self, args);
|
|
55
|
+
function _next(value) {
|
|
56
|
+
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
|
|
57
|
+
}
|
|
58
|
+
function _throw(err) {
|
|
59
|
+
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
|
|
60
|
+
}
|
|
61
|
+
_next(void 0);
|
|
62
|
+
});
|
|
63
|
+
};
|
|
64
|
+
}
|
|
65
|
+
function _instanceof(left, right) {
|
|
66
|
+
return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
|
|
67
|
+
}
|
|
68
|
+
function _iterable_to_array_limit(arr, i) {
|
|
69
|
+
var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
|
|
70
|
+
if (_i != null) {
|
|
71
|
+
var _arr = [], _n = !0, _d = !1, _s, _e;
|
|
72
|
+
try {
|
|
73
|
+
for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
|
|
74
|
+
;
|
|
75
|
+
} catch (err) {
|
|
76
|
+
_d = !0, _e = err;
|
|
77
|
+
} finally {
|
|
78
|
+
try {
|
|
79
|
+
!_n && _i.return != null && _i.return();
|
|
80
|
+
} finally {
|
|
81
|
+
if (_d)
|
|
82
|
+
throw _e;
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
return _arr;
|
|
86
|
+
}
|
|
87
|
+
}
|
|
88
|
+
function _non_iterable_rest() {
|
|
89
|
+
throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
90
|
+
}
|
|
91
|
+
function _sliced_to_array(arr, i) {
|
|
92
|
+
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
|
|
93
|
+
}
|
|
94
|
+
function _unsupported_iterable_to_array(o, minLen) {
|
|
95
|
+
if (o) {
|
|
96
|
+
if (typeof o == "string")
|
|
97
|
+
return _array_like_to_array(o, minLen);
|
|
98
|
+
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
99
|
+
if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
|
|
100
|
+
return Array.from(n);
|
|
101
|
+
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
|
|
102
|
+
return _array_like_to_array(o, minLen);
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
function _ts_generator(thisArg, body) {
|
|
106
|
+
var f, y, t, g, _ = {
|
|
107
|
+
label: 0,
|
|
108
|
+
sent: function() {
|
|
109
|
+
if (t[0] & 1)
|
|
110
|
+
throw t[1];
|
|
111
|
+
return t[1];
|
|
112
|
+
},
|
|
113
|
+
trys: [],
|
|
114
|
+
ops: []
|
|
115
|
+
};
|
|
116
|
+
return g = {
|
|
117
|
+
next: verb(0),
|
|
118
|
+
throw: verb(1),
|
|
119
|
+
return: verb(2)
|
|
120
|
+
}, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
|
|
121
|
+
return this;
|
|
122
|
+
}), g;
|
|
123
|
+
function verb(n) {
|
|
124
|
+
return function(v) {
|
|
125
|
+
return step([
|
|
126
|
+
n,
|
|
127
|
+
v
|
|
128
|
+
]);
|
|
129
|
+
};
|
|
130
|
+
}
|
|
131
|
+
function step(op) {
|
|
132
|
+
if (f)
|
|
133
|
+
throw new TypeError("Generator is already executing.");
|
|
134
|
+
for (; _; )
|
|
135
|
+
try {
|
|
136
|
+
if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
|
|
137
|
+
return t;
|
|
138
|
+
switch (y = 0, t && (op = [
|
|
139
|
+
op[0] & 2,
|
|
140
|
+
t.value
|
|
141
|
+
]), op[0]) {
|
|
142
|
+
case 0:
|
|
143
|
+
case 1:
|
|
144
|
+
t = op;
|
|
145
|
+
break;
|
|
146
|
+
case 4:
|
|
147
|
+
return _.label++, {
|
|
148
|
+
value: op[1],
|
|
149
|
+
done: !1
|
|
150
|
+
};
|
|
151
|
+
case 5:
|
|
152
|
+
_.label++, y = op[1], op = [
|
|
153
|
+
0
|
|
154
|
+
];
|
|
155
|
+
continue;
|
|
156
|
+
case 7:
|
|
157
|
+
op = _.ops.pop(), _.trys.pop();
|
|
158
|
+
continue;
|
|
159
|
+
default:
|
|
160
|
+
if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
161
|
+
_ = 0;
|
|
162
|
+
continue;
|
|
163
|
+
}
|
|
164
|
+
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
|
|
165
|
+
_.label = op[1];
|
|
166
|
+
break;
|
|
167
|
+
}
|
|
168
|
+
if (op[0] === 6 && _.label < t[1]) {
|
|
169
|
+
_.label = t[1], t = op;
|
|
170
|
+
break;
|
|
171
|
+
}
|
|
172
|
+
if (t && _.label < t[2]) {
|
|
173
|
+
_.label = t[2], _.ops.push(op);
|
|
174
|
+
break;
|
|
175
|
+
}
|
|
176
|
+
t[2] && _.ops.pop(), _.trys.pop();
|
|
177
|
+
continue;
|
|
178
|
+
}
|
|
179
|
+
op = body.call(thisArg, _);
|
|
180
|
+
} catch (e) {
|
|
181
|
+
op = [
|
|
182
|
+
6,
|
|
183
|
+
e
|
|
184
|
+
], y = 0;
|
|
185
|
+
} finally {
|
|
186
|
+
f = t = 0;
|
|
187
|
+
}
|
|
188
|
+
if (op[0] & 5)
|
|
189
|
+
throw op[1];
|
|
190
|
+
return {
|
|
191
|
+
value: op[0] ? op[1] : void 0,
|
|
192
|
+
done: !0
|
|
193
|
+
};
|
|
194
|
+
}
|
|
195
|
+
}
|
|
31
196
|
import_marked.marked.setOptions({
|
|
32
197
|
headerIds: !1,
|
|
33
198
|
mangle: !1,
|
|
34
199
|
renderer: new import_marked_terminal.default()
|
|
35
200
|
});
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
201
|
+
var home = (0, import_os.homedir)(), tamaguiDir = import_path.default.join(home, ".tamagui"), generatedPackageTypes = [
|
|
202
|
+
"font",
|
|
203
|
+
"icon"
|
|
204
|
+
], installGeneratedPackage = function() {
|
|
205
|
+
var _ref = _async_to_generator(function(type, packagesPath) {
|
|
206
|
+
var repoName, tempDir, meta, _, result, packageName, packageDir, finalDir, readmePath;
|
|
207
|
+
return _ts_generator(this, function(_state) {
|
|
208
|
+
switch (_state.label) {
|
|
209
|
+
case 0:
|
|
210
|
+
if (packagesPath = packagesPath || import_path.default.join(process.cwd(), "packages"), !generatedPackageTypes.includes(type))
|
|
211
|
+
throw new Error("".concat(type ? 'Type "'.concat(type, '" is Not supported.') : "No type provided.", " Supported types: ").concat(generatedPackageTypes.join(", ")));
|
|
212
|
+
return repoName = type === "font" ? "tamagui-google-fonts" : "tamagui-iconify", console.info("Setting up ".concat(import_chalk.default.blueBright(tamaguiDir), "...")), [
|
|
213
|
+
4,
|
|
214
|
+
(0, import_fs_extra.ensureDir)(tamaguiDir)
|
|
215
|
+
];
|
|
216
|
+
case 1:
|
|
217
|
+
_state.sent(), tempDir = import_path.default.join(tamaguiDir, repoName), (0, import_fs.existsSync)(tempDir) && (0, import_fs.rmSync)(tempDir, {
|
|
218
|
+
recursive: !0
|
|
219
|
+
});
|
|
220
|
+
try {
|
|
221
|
+
process.chdir(tamaguiDir);
|
|
222
|
+
try {
|
|
223
|
+
console.info("Attempting to clone with SSH"), (0, import_child_process.execSync)("git clone -n --depth=1 --branch generated --filter=tree:0 git@github.com:tamagui/".concat(repoName, ".git"));
|
|
224
|
+
} catch {
|
|
225
|
+
console.info("SSH failed - Attempting to c lone with HTTPS"), (0, import_child_process.execSync)("git clone -n --depth=1 --branch generated --filter=tree:0 https://github.com/tamagui/".concat(repoName));
|
|
226
|
+
}
|
|
227
|
+
process.chdir(tempDir), (0, import_child_process.execSync)([
|
|
228
|
+
"git sparse-checkout set --no-cone meta",
|
|
229
|
+
"git checkout"
|
|
230
|
+
].join(" && "));
|
|
231
|
+
} catch (error) {
|
|
232
|
+
if (_instanceof(error, Error))
|
|
233
|
+
throw error != null && error.stderr.includes("Repository not found") && (console.info(import_chalk.default.yellow("You don't have access to Tamagui ".concat(type === "font" ? "fonts" : "icons", ". Check \u{1F961} Tamagui Takeout (https://tamagui.dev/takeout) for more info."))), (0, import_opener.default)("https://tamagui.dev/takeout"), process.exit(0)), error;
|
|
234
|
+
}
|
|
235
|
+
return _ = JSON.parse, [
|
|
236
|
+
4,
|
|
237
|
+
(0, import_promises.readFile)(import_path.default.join(tamaguiDir, repoName, "meta", "data.json")).then(function(r) {
|
|
238
|
+
return r.toString();
|
|
239
|
+
})
|
|
240
|
+
];
|
|
241
|
+
case 2:
|
|
242
|
+
return meta = _.apply(JSON, [
|
|
243
|
+
_state.sent()
|
|
244
|
+
]), console.info(import_chalk.default.gray("Use \u21E7/\u21E9 to navigate. Use tab to cycle the result. Use Page Up/Page Down (on Mac: fn + \u21E7 / \u21E9) to change page. Hit enter to select the highlighted item below the prompt.")), [
|
|
245
|
+
4,
|
|
246
|
+
(0, import_prompts.default)({
|
|
247
|
+
name: "packageName",
|
|
248
|
+
type: "autocomplete",
|
|
249
|
+
message: type === "icon" ? "Pick an icon pack:" : type === "font" ? "Pick a font:" : "Pick one:",
|
|
250
|
+
choices: Object.entries(meta).map(function(param) {
|
|
251
|
+
var _param = _sliced_to_array(param, 2), slug = _param[0], data = _param[1];
|
|
252
|
+
return {
|
|
253
|
+
title: type === "font" ? "".concat(slug, ": ").concat(data.weights.length, " weights, ").concat(data.styles.length, " styles, ").concat(data.subsets.length, " subsets (https://fonts.google.com/specimen/").concat((0, import_change_case.pascalCase)(slug), ")") : "".concat(data.name, ": ").concat(data.total, " icons, ").concat(data.license.title, " license (").concat(data.author.url, ")"),
|
|
254
|
+
value: slug
|
|
255
|
+
};
|
|
256
|
+
})
|
|
257
|
+
})
|
|
258
|
+
];
|
|
259
|
+
case 3:
|
|
260
|
+
return result = _state.sent(), packageName = "".concat(type, "-").concat(result.packageName), packageDir = import_path.default.join(tempDir, "packages", packageName), process.chdir(tempDir), (0, import_child_process.execSync)([
|
|
261
|
+
"git sparse-checkout set --no-cone packages/".concat(packageName),
|
|
262
|
+
"git checkout"
|
|
263
|
+
].join(" && ")), finalDir = import_path.default.join(packagesPath, packageName), [
|
|
264
|
+
4,
|
|
265
|
+
(0, import_fs_extra.ensureDir)(packagesPath)
|
|
266
|
+
];
|
|
267
|
+
case 4:
|
|
268
|
+
return _state.sent(), [
|
|
269
|
+
4,
|
|
270
|
+
(0, import_fs_extra.copy)(packageDir, finalDir)
|
|
271
|
+
];
|
|
272
|
+
case 5:
|
|
273
|
+
return _state.sent(), console.info(), console.info(import_chalk.default.green("Created the package under ".concat(finalDir))), console.info(), readmePath = import_path.default.join(finalDir, "README.md"), (0, import_fs.existsSync)(readmePath) && console.info(import_marked.marked.parse((0, import_fs_extra.readFileSync)(readmePath).toString())), [
|
|
274
|
+
2
|
|
275
|
+
];
|
|
276
|
+
}
|
|
277
|
+
});
|
|
278
|
+
});
|
|
279
|
+
return function(type, packagesPath) {
|
|
280
|
+
return _ref.apply(this, arguments);
|
|
281
|
+
};
|
|
282
|
+
}();
|
|
94
283
|
// Annotate the CommonJS export names for ESM import in node:
|
|
95
284
|
0 && (module.exports = {
|
|
96
285
|
generatedPackageTypes,
|
package/dist/add.native.js.map
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 3,
|
|
3
|
-
"sources": ["../src/add.ts"],
|
|
4
|
-
"mappings": "
|
|
5
|
-
"names": ["TerminalRenderer", "path", "chalk", "open", "prompts"]
|
|
3
|
+
"sources": ["../src/Users/n8/tamagui/packages/cli/src/add.ts"],
|
|
4
|
+
"mappings": "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",
|
|
5
|
+
"names": ["marked", "setOptions", "headerIds", "mangle", "renderer", "TerminalRenderer", "home", "homedir", "tamaguiDir", "path", "join", "generatedPackageTypes", "installGeneratedPackage", "type", "packagesPath", "repoName", "tempDir", "meta", "result", "packageName", "packageDir", "finalDir", "readmePath", "process", "cwd", "includes", "Error", "console", "info", "chalk", "blueBright", "ensureDir", "existsSync", "rmSync", "recursive", "chdir", "execSync", "error", "stderr", "yellow", "open", "exit", "JSON", "parse", "readFile", "then", "r", "toString", "gray", "prompts", "name", "message", "choices", "Object", "entries", "map", "slug", "data", "title", "weights", "length", "styles", "pascalCase", "subsets", "total", "license", "author", "url", "value", "copy", "green", "readFileSync"]
|
|
6
6
|
}
|
package/dist/build.native.js
CHANGED
|
@@ -27,38 +27,203 @@ __export(build_exports, {
|
|
|
27
27
|
});
|
|
28
28
|
module.exports = __toCommonJS(build_exports);
|
|
29
29
|
var import_path = require("path"), import_static = require("@tamagui/static"), import_chokidar = __toESM(require("chokidar")), import_fs_extra = require("fs-extra");
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
30
|
+
function asyncGeneratorStep(gen, resolve2, reject, _next, _throw, key, arg) {
|
|
31
|
+
try {
|
|
32
|
+
var info = gen[key](arg), value = info.value;
|
|
33
|
+
} catch (error) {
|
|
34
|
+
reject(error);
|
|
35
|
+
return;
|
|
36
|
+
}
|
|
37
|
+
info.done ? resolve2(value) : Promise.resolve(value).then(_next, _throw);
|
|
38
|
+
}
|
|
39
|
+
function _async_to_generator(fn) {
|
|
40
|
+
return function() {
|
|
41
|
+
var self = this, args = arguments;
|
|
42
|
+
return new Promise(function(resolve2, reject) {
|
|
43
|
+
var gen = fn.apply(self, args);
|
|
44
|
+
function _next(value) {
|
|
45
|
+
asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "next", value);
|
|
46
|
+
}
|
|
47
|
+
function _throw(err) {
|
|
48
|
+
asyncGeneratorStep(gen, resolve2, reject, _next, _throw, "throw", err);
|
|
49
|
+
}
|
|
50
|
+
_next(void 0);
|
|
51
|
+
});
|
|
52
|
+
};
|
|
53
|
+
}
|
|
54
|
+
function _ts_generator(thisArg, body) {
|
|
55
|
+
var f, y, t, g, _ = {
|
|
56
|
+
label: 0,
|
|
57
|
+
sent: function() {
|
|
58
|
+
if (t[0] & 1)
|
|
59
|
+
throw t[1];
|
|
60
|
+
return t[1];
|
|
61
|
+
},
|
|
62
|
+
trys: [],
|
|
63
|
+
ops: []
|
|
64
|
+
};
|
|
65
|
+
return g = {
|
|
66
|
+
next: verb(0),
|
|
67
|
+
throw: verb(1),
|
|
68
|
+
return: verb(2)
|
|
69
|
+
}, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
|
|
70
|
+
return this;
|
|
71
|
+
}), g;
|
|
72
|
+
function verb(n) {
|
|
73
|
+
return function(v) {
|
|
74
|
+
return step([
|
|
75
|
+
n,
|
|
76
|
+
v
|
|
77
|
+
]);
|
|
78
|
+
};
|
|
79
|
+
}
|
|
80
|
+
function step(op) {
|
|
81
|
+
if (f)
|
|
82
|
+
throw new TypeError("Generator is already executing.");
|
|
83
|
+
for (; _; )
|
|
84
|
+
try {
|
|
85
|
+
if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
|
|
86
|
+
return t;
|
|
87
|
+
switch (y = 0, t && (op = [
|
|
88
|
+
op[0] & 2,
|
|
89
|
+
t.value
|
|
90
|
+
]), op[0]) {
|
|
91
|
+
case 0:
|
|
92
|
+
case 1:
|
|
93
|
+
t = op;
|
|
94
|
+
break;
|
|
95
|
+
case 4:
|
|
96
|
+
return _.label++, {
|
|
97
|
+
value: op[1],
|
|
98
|
+
done: !1
|
|
99
|
+
};
|
|
100
|
+
case 5:
|
|
101
|
+
_.label++, y = op[1], op = [
|
|
102
|
+
0
|
|
103
|
+
];
|
|
104
|
+
continue;
|
|
105
|
+
case 7:
|
|
106
|
+
op = _.ops.pop(), _.trys.pop();
|
|
107
|
+
continue;
|
|
108
|
+
default:
|
|
109
|
+
if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
110
|
+
_ = 0;
|
|
111
|
+
continue;
|
|
112
|
+
}
|
|
113
|
+
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
|
|
114
|
+
_.label = op[1];
|
|
115
|
+
break;
|
|
116
|
+
}
|
|
117
|
+
if (op[0] === 6 && _.label < t[1]) {
|
|
118
|
+
_.label = t[1], t = op;
|
|
119
|
+
break;
|
|
120
|
+
}
|
|
121
|
+
if (t && _.label < t[2]) {
|
|
122
|
+
_.label = t[2], _.ops.push(op);
|
|
123
|
+
break;
|
|
124
|
+
}
|
|
125
|
+
t[2] && _.ops.pop(), _.trys.pop();
|
|
126
|
+
continue;
|
|
127
|
+
}
|
|
128
|
+
op = body.call(thisArg, _);
|
|
129
|
+
} catch (e) {
|
|
130
|
+
op = [
|
|
131
|
+
6,
|
|
132
|
+
e
|
|
133
|
+
], y = 0;
|
|
134
|
+
} finally {
|
|
135
|
+
f = t = 0;
|
|
136
|
+
}
|
|
137
|
+
if (op[0] & 5)
|
|
138
|
+
throw op[1];
|
|
139
|
+
return {
|
|
140
|
+
value: op[0] ? op[1] : void 0,
|
|
141
|
+
done: !0
|
|
142
|
+
};
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
var build = function() {
|
|
146
|
+
var _ref = _async_to_generator(function(options) {
|
|
147
|
+
var entry, sourceDir, promises, targets;
|
|
148
|
+
return _ts_generator(this, function(_state) {
|
|
149
|
+
switch (_state.label) {
|
|
150
|
+
case 0:
|
|
151
|
+
if (entry = options.pkgJson.source, !entry)
|
|
152
|
+
throw new Error('Must add "source" to package.json pointing to your source directory');
|
|
153
|
+
return sourceDir = (0, import_path.dirname)(entry), promises = [], targets = [
|
|
154
|
+
"web"
|
|
155
|
+
], [
|
|
156
|
+
4,
|
|
157
|
+
new Promise(function(res) {
|
|
158
|
+
import_chokidar.default.watch(sourceDir, {}).on("add", function(relativePath) {
|
|
159
|
+
var sourcePath = (0, import_path.resolve)(process.cwd(), relativePath);
|
|
160
|
+
promises.push(_async_to_generator(function() {
|
|
161
|
+
return _ts_generator(this, function(_state2) {
|
|
162
|
+
switch (_state2.label) {
|
|
163
|
+
case 0:
|
|
164
|
+
return [
|
|
165
|
+
4,
|
|
166
|
+
Promise.all(targets.map(function() {
|
|
167
|
+
var _ref2 = _async_to_generator(function(target) {
|
|
168
|
+
var _process_env, source, extractor, out;
|
|
169
|
+
return _ts_generator(this, function(_state3) {
|
|
170
|
+
switch (_state3.label) {
|
|
171
|
+
case 0:
|
|
172
|
+
return process.env.TAMAGUI_TARGET = target, options.debug && ((_process_env = process.env).NODE_ENV || (_process_env.NODE_ENV = "development")), [
|
|
173
|
+
4,
|
|
174
|
+
(0, import_fs_extra.readFile)(sourcePath, "utf-8")
|
|
175
|
+
];
|
|
176
|
+
case 1:
|
|
177
|
+
return source = _state3.sent(), extractor = (0, import_static.createExtractor)(), [
|
|
178
|
+
4,
|
|
179
|
+
(0, import_static.extractToClassNames)({
|
|
180
|
+
extractor,
|
|
181
|
+
source,
|
|
182
|
+
sourcePath,
|
|
183
|
+
options: options.tamaguiOptions,
|
|
184
|
+
shouldPrintDebug: options.debug || !1
|
|
185
|
+
})
|
|
186
|
+
];
|
|
187
|
+
case 2:
|
|
188
|
+
return out = _state3.sent(), [
|
|
189
|
+
2
|
|
190
|
+
];
|
|
191
|
+
}
|
|
192
|
+
});
|
|
193
|
+
});
|
|
194
|
+
return function(target) {
|
|
195
|
+
return _ref2.apply(this, arguments);
|
|
196
|
+
};
|
|
197
|
+
}()))
|
|
198
|
+
];
|
|
199
|
+
case 1:
|
|
200
|
+
return _state2.sent(), [
|
|
201
|
+
2
|
|
202
|
+
];
|
|
203
|
+
}
|
|
204
|
+
});
|
|
205
|
+
})());
|
|
206
|
+
}).on("ready", function() {
|
|
207
|
+
res();
|
|
52
208
|
});
|
|
53
209
|
})
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
210
|
+
];
|
|
211
|
+
case 1:
|
|
212
|
+
return _state.sent(), [
|
|
213
|
+
4,
|
|
214
|
+
Promise.all(promises)
|
|
215
|
+
];
|
|
216
|
+
case 2:
|
|
217
|
+
return _state.sent(), [
|
|
218
|
+
2
|
|
219
|
+
];
|
|
220
|
+
}
|
|
59
221
|
});
|
|
60
|
-
})
|
|
61
|
-
|
|
222
|
+
});
|
|
223
|
+
return function(options) {
|
|
224
|
+
return _ref.apply(this, arguments);
|
|
225
|
+
};
|
|
226
|
+
}();
|
|
62
227
|
// Annotate the CommonJS export names for ESM import in node:
|
|
63
228
|
0 && (module.exports = {
|
|
64
229
|
build
|
package/dist/build.native.js.map
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"version": 3,
|
|
3
|
-
"sources": ["../src/build.ts"],
|
|
4
|
-
"mappings": "
|
|
5
|
-
"names": ["chokidar"]
|
|
3
|
+
"sources": ["../src/Users/n8/tamagui/packages/cli/src/build.ts"],
|
|
4
|
+
"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,kBAAiC,iBAEjC,gBAAqD,4BAErD,kBAAqB,8BACrB,kBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElB,IAAMA,QAAAA,WAAAA;aAAQ,oBAAA,SAAOC,SAAAA;QAGpBC,OAIAC,WACAC,UACAC;;;;AALN,cADMH,QAAQD,QAAQK,QAAQC,QAC1B,CAACL;AACH,kBAAM,IAAIM,MAAO,qEAAA;AAEbL,iCAAYM,qBAAQP,KAAAA,GACpBE,WAAAA,CAAAA,GACAC,UAAAA;YAAW;aAEjB;;YAAM,IAAIK,QAAc,SAACC,KAAAA;AACvBC,8BAAAA,QAEGC,MAAMV,WAAW,CAElB,CAAA,EACCW,GAAG,OAAO,SAACC,cAAAA;AACV,oBAAMC,iBAAaC,qBAAQC,QAAQC,IAAG,GAAIJ,YAAAA;AAE1CX,yBAASgB,KACN,oBAAA,WAAA;;;;AACC,+BAAA;;0BAAMV,QAAQW,IACZhB,QAAQiB,IAAG,WAAA;wCAAC,oBAAA,SAAOC,QAAAA;kCAGfL,cAEIX,QACAiB,WACAC;;;;AANNP,mDAAQQ,IAAIC,iBAAiBJ,QACzBtB,QAAQ2B,WACVV,eAAAA,QAAQQ,KAAIG,aAAZX,aAAYW,WAAa,iBAEZ;;0CAAMC,0BAASd,YAAY,OAAA;;;AAApCT,oDAASwB,QAAA,KAAA,GACTP,gBAAYQ,+BAAAA,GACN;;0CAAMC,mCAAoB;wCACpCT;wCACAjB;wCACAS;wCACAf,SAASA,QAAQiC;wCACjBC,kBAAkBlC,QAAQ2B,SAAS;sCACrC,CAAA;;;AANMH,iDAAMM,QAAA,KAAA;;;;;4BASd,CAAA;4CAhBmBR,QAAAA;;;;;;AADrB,+BAAAQ,QAAA,KAAA;;;;;gBAmBF,CAAA,EAAA,CAAA;cAEJ,CAAA,EACCjB,GAAG,SAAS,WAAA;AACXH,oBAAAA;cACF,CAAA;YACJ,CAAA;;;AApCA,wBAAA,KAAA,GAsCA;;YAAMD,QAAQW,IAAIjB,QAAAA;;;AAAlB,wBAAA,KAAA;;;;;EACF,CAAA;kBAlD4BH,SAAAA;;;;",
|
|
5
|
+
"names": ["build", "options", "entry", "sourceDir", "promises", "targets", "pkgJson", "source", "Error", "dirname", "Promise", "res", "chokidar", "watch", "on", "relativePath", "sourcePath", "resolve", "process", "cwd", "push", "all", "map", "target", "extractor", "out", "env", "TAMAGUI_TARGET", "debug", "NODE_ENV", "readFile", "_state", "createExtractor", "extractToClassNames", "tamaguiOptions", "shouldPrintDebug"]
|
|
6
6
|
}
|