@fumadocs/cli 1.2.0 → 1.2.1
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/build/index.d.ts +141 -137
- package/dist/build/index.d.ts.map +1 -0
- package/dist/build/index.js +257 -323
- package/dist/build/index.js.map +1 -0
- package/dist/index.d.ts +1 -1
- package/dist/index.js +566 -751
- package/dist/index.js.map +1 -0
- package/package.json +16 -16
package/dist/build/index.js
CHANGED
|
@@ -1,339 +1,273 @@
|
|
|
1
|
-
|
|
2
|
-
import * as
|
|
3
|
-
import * as path2 from "path";
|
|
1
|
+
import * as fs$1 from "node:fs/promises";
|
|
2
|
+
import * as path$1 from "node:path";
|
|
4
3
|
import picocolors from "picocolors";
|
|
5
|
-
|
|
6
|
-
// src/build/compiler.ts
|
|
7
|
-
import * as fs from "fs/promises";
|
|
8
|
-
import * as path from "path";
|
|
9
4
|
import { Project, ts } from "ts-morph";
|
|
5
|
+
|
|
6
|
+
//#region src/build/compiler.ts
|
|
10
7
|
var RegistryCompiler = class {
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
name: input.name,
|
|
49
|
-
title: input.title,
|
|
50
|
-
description: input.description
|
|
51
|
-
});
|
|
52
|
-
}
|
|
53
|
-
output.components.push(comp);
|
|
54
|
-
}
|
|
55
|
-
return output;
|
|
56
|
-
}
|
|
8
|
+
constructor(registry) {
|
|
9
|
+
this.raw = registry;
|
|
10
|
+
this.project = new Project({ tsConfigFilePath: path$1.join(registry.dir, registry.tsconfigPath) });
|
|
11
|
+
}
|
|
12
|
+
async readPackageJson() {
|
|
13
|
+
if (typeof this.raw.packageJson !== "string") return this.raw.packageJson;
|
|
14
|
+
return fs$1.readFile(path$1.join(this.raw.dir, this.raw.packageJson)).then((res) => JSON.parse(res.toString())).catch(() => void 0);
|
|
15
|
+
}
|
|
16
|
+
async createSourceFile(file) {
|
|
17
|
+
const content = await fs$1.readFile(file);
|
|
18
|
+
return this.project.createSourceFile(file, content.toString(), { overwrite: true });
|
|
19
|
+
}
|
|
20
|
+
async compile() {
|
|
21
|
+
const registry = this.raw;
|
|
22
|
+
this.resolver = new RegistryResolver(this, await this.readPackageJson());
|
|
23
|
+
const output = {
|
|
24
|
+
name: registry.name,
|
|
25
|
+
info: {
|
|
26
|
+
indexes: [],
|
|
27
|
+
env: registry.env,
|
|
28
|
+
variables: registry.variables
|
|
29
|
+
},
|
|
30
|
+
components: []
|
|
31
|
+
};
|
|
32
|
+
const builtComps = await Promise.all(registry.components.map(async (component) => {
|
|
33
|
+
return [component, await new ComponentCompiler(this, component).build()];
|
|
34
|
+
}));
|
|
35
|
+
for (const [input, comp] of builtComps) {
|
|
36
|
+
if (!input.unlisted) output.info.indexes.push({
|
|
37
|
+
name: input.name,
|
|
38
|
+
title: input.title,
|
|
39
|
+
description: input.description
|
|
40
|
+
});
|
|
41
|
+
output.components.push(comp);
|
|
42
|
+
}
|
|
43
|
+
return output;
|
|
44
|
+
}
|
|
57
45
|
};
|
|
58
46
|
var RegistryResolver = class {
|
|
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
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
const comp = this.fileToComponent.get(relativeFile);
|
|
105
|
-
if (!comp) return;
|
|
106
|
-
return {
|
|
107
|
-
component: comp[0],
|
|
108
|
-
file: comp[1]
|
|
109
|
-
};
|
|
110
|
-
}
|
|
47
|
+
constructor(compiler, packageJson = {}) {
|
|
48
|
+
this.compiler = compiler;
|
|
49
|
+
this.fileToComponent = /* @__PURE__ */ new Map();
|
|
50
|
+
const registry = compiler.raw;
|
|
51
|
+
for (const comp of registry.components) for (const file of comp.files) {
|
|
52
|
+
if (this.fileToComponent.has(file.path)) console.warn(`the same file ${file.path} exists in multiple component, you should make the shared file a separate component.`);
|
|
53
|
+
this.fileToComponent.set(file.path, [comp, file]);
|
|
54
|
+
}
|
|
55
|
+
this.deps = {
|
|
56
|
+
...packageJson?.dependencies,
|
|
57
|
+
...registry.dependencies
|
|
58
|
+
};
|
|
59
|
+
this.devDeps = {
|
|
60
|
+
...packageJson?.devDependencies,
|
|
61
|
+
...registry.devDependencies
|
|
62
|
+
};
|
|
63
|
+
}
|
|
64
|
+
getDepFromSpecifier(specifier) {
|
|
65
|
+
return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
|
|
66
|
+
}
|
|
67
|
+
getDepInfo(name) {
|
|
68
|
+
if (name in this.deps) return {
|
|
69
|
+
name,
|
|
70
|
+
type: "runtime",
|
|
71
|
+
version: this.deps[name]
|
|
72
|
+
};
|
|
73
|
+
if (name in this.devDeps) return {
|
|
74
|
+
name,
|
|
75
|
+
type: "dev",
|
|
76
|
+
version: this.devDeps[name]
|
|
77
|
+
};
|
|
78
|
+
console.warn(`dep info for ${name} cannot be found`);
|
|
79
|
+
}
|
|
80
|
+
getComponentByName(name) {
|
|
81
|
+
return this.compiler.raw.components.find((comp) => comp.name === name);
|
|
82
|
+
}
|
|
83
|
+
getSubComponent(file) {
|
|
84
|
+
const relativeFile = path$1.relative(this.compiler.raw.dir, file);
|
|
85
|
+
const comp = this.fileToComponent.get(relativeFile);
|
|
86
|
+
if (!comp) return;
|
|
87
|
+
return {
|
|
88
|
+
component: comp[0],
|
|
89
|
+
file: comp[1]
|
|
90
|
+
};
|
|
91
|
+
}
|
|
111
92
|
};
|
|
112
93
|
var ComponentCompiler = class {
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
);
|
|
231
|
-
if (!resolved) return;
|
|
232
|
-
if (onResolve) resolved = onResolve(resolved);
|
|
233
|
-
const out = writeReference(resolved);
|
|
234
|
-
if (out) specifier.setLiteralValue(out);
|
|
235
|
-
};
|
|
236
|
-
const sourceFile = await this.compiler.createSourceFile(sourceFilePath);
|
|
237
|
-
for (const item of sourceFile.getImportDeclarations()) {
|
|
238
|
-
process2(item.getModuleSpecifier(), item.getModuleSpecifierSourceFile());
|
|
239
|
-
}
|
|
240
|
-
for (const item of sourceFile.getExportDeclarations()) {
|
|
241
|
-
const specifier = item.getModuleSpecifier();
|
|
242
|
-
if (!specifier) continue;
|
|
243
|
-
process2(specifier, item.getModuleSpecifierSourceFile());
|
|
244
|
-
}
|
|
245
|
-
const calls = sourceFile.getDescendantsOfKind(ts.SyntaxKind.CallExpression);
|
|
246
|
-
for (const expression of calls) {
|
|
247
|
-
if (expression.getExpression().isKind(ts.SyntaxKind.ImportKeyword) && expression.getArguments().length === 1) {
|
|
248
|
-
const argument = expression.getArguments()[0];
|
|
249
|
-
if (!argument.isKind(ts.SyntaxKind.StringLiteral)) continue;
|
|
250
|
-
process2(
|
|
251
|
-
argument,
|
|
252
|
-
argument.getSymbol()?.getDeclarations()[0].getSourceFile()
|
|
253
|
-
);
|
|
254
|
-
}
|
|
255
|
-
}
|
|
256
|
-
return {
|
|
257
|
-
content: sourceFile.getFullText(),
|
|
258
|
-
type: file.type,
|
|
259
|
-
path: file.path,
|
|
260
|
-
target: file.target
|
|
261
|
-
};
|
|
262
|
-
}
|
|
94
|
+
constructor(compiler, component) {
|
|
95
|
+
this.compiler = compiler;
|
|
96
|
+
this.component = component;
|
|
97
|
+
this.processedFiles = /* @__PURE__ */ new Set();
|
|
98
|
+
this.subComponents = /* @__PURE__ */ new Set();
|
|
99
|
+
this.devDependencies = /* @__PURE__ */ new Map();
|
|
100
|
+
this.dependencies = /* @__PURE__ */ new Map();
|
|
101
|
+
this.registry = compiler.raw;
|
|
102
|
+
}
|
|
103
|
+
toImportPath(file) {
|
|
104
|
+
let filePath = file.target ?? file.path;
|
|
105
|
+
if (filePath.startsWith("./")) filePath = filePath.slice(2);
|
|
106
|
+
return `@/${filePath.replaceAll(path$1.sep, "/")}`;
|
|
107
|
+
}
|
|
108
|
+
async build() {
|
|
109
|
+
return {
|
|
110
|
+
name: this.component.name,
|
|
111
|
+
title: this.component.title,
|
|
112
|
+
description: this.component.description,
|
|
113
|
+
files: (await Promise.all(this.component.files.map((file) => this.buildFileAndDeps(file)))).flat(),
|
|
114
|
+
subComponents: Array.from(this.subComponents),
|
|
115
|
+
dependencies: Object.fromEntries(this.dependencies),
|
|
116
|
+
devDependencies: Object.fromEntries(this.devDependencies)
|
|
117
|
+
};
|
|
118
|
+
}
|
|
119
|
+
async buildFileAndDeps(file) {
|
|
120
|
+
if (this.processedFiles.has(file.path)) return [];
|
|
121
|
+
this.processedFiles.add(file.path);
|
|
122
|
+
const resolver = this.compiler.resolver;
|
|
123
|
+
const queue = [];
|
|
124
|
+
return [await this.buildFile(file, (reference) => {
|
|
125
|
+
if (reference.type === "custom") return reference.specifier;
|
|
126
|
+
if (reference.type === "file") {
|
|
127
|
+
const refFile = this.registry.onUnknownFile?.(reference.file);
|
|
128
|
+
if (refFile) {
|
|
129
|
+
queue.push(refFile);
|
|
130
|
+
return this.toImportPath(refFile);
|
|
131
|
+
}
|
|
132
|
+
if (refFile === false) return;
|
|
133
|
+
throw new Error(`Unknown file ${reference.file} referenced by ${file.path}`);
|
|
134
|
+
}
|
|
135
|
+
if (reference.type === "sub-component") {
|
|
136
|
+
const resolved = reference.resolved;
|
|
137
|
+
if (resolved.component.name !== this.component.name) if (resolved.type === "remote") this.subComponents.add({
|
|
138
|
+
type: "http",
|
|
139
|
+
baseUrl: resolved.registryName,
|
|
140
|
+
component: resolved.component.name
|
|
141
|
+
});
|
|
142
|
+
else this.subComponents.add(resolved.component.name);
|
|
143
|
+
return this.toImportPath(resolved.file);
|
|
144
|
+
}
|
|
145
|
+
const dep = resolver.getDepInfo(reference.dep);
|
|
146
|
+
if (dep) (dep.type === "dev" ? this.devDependencies : this.dependencies).set(dep.name, dep.version);
|
|
147
|
+
return reference.specifier;
|
|
148
|
+
}), ...(await Promise.all(queue.map((file$1) => this.buildFileAndDeps(file$1)))).flat()];
|
|
149
|
+
}
|
|
150
|
+
resolveImport(sourceFilePath, specifier, specified) {
|
|
151
|
+
let filePath;
|
|
152
|
+
if (specified) filePath = specified.getFilePath();
|
|
153
|
+
else if (specifier.startsWith("./") || specifier.startsWith("../")) filePath = path$1.join(path$1.dirname(sourceFilePath), specifier);
|
|
154
|
+
else {
|
|
155
|
+
if (!specifier.startsWith("node:")) console.warn(`Unknown specifier ${specifier}, skipping for now`);
|
|
156
|
+
return;
|
|
157
|
+
}
|
|
158
|
+
const resolver = this.compiler.resolver;
|
|
159
|
+
if (path$1.relative(this.registry.dir, filePath).startsWith("../")) return {
|
|
160
|
+
type: "dependency",
|
|
161
|
+
dep: resolver.getDepFromSpecifier(specifier),
|
|
162
|
+
specifier
|
|
163
|
+
};
|
|
164
|
+
const sub = resolver.getSubComponent(filePath);
|
|
165
|
+
if (sub) return {
|
|
166
|
+
type: "sub-component",
|
|
167
|
+
resolved: {
|
|
168
|
+
type: "local",
|
|
169
|
+
component: sub.component,
|
|
170
|
+
file: sub.file
|
|
171
|
+
}
|
|
172
|
+
};
|
|
173
|
+
return {
|
|
174
|
+
type: "file",
|
|
175
|
+
file: filePath
|
|
176
|
+
};
|
|
177
|
+
}
|
|
178
|
+
async buildFile(file, writeReference) {
|
|
179
|
+
const sourceFilePath = path$1.join(this.registry.dir, file.path);
|
|
180
|
+
/**
|
|
181
|
+
* Process import paths
|
|
182
|
+
*/
|
|
183
|
+
const process$1 = (specifier, specifiedFile) => {
|
|
184
|
+
const onResolve = this.component.onResolve ?? this.registry.onResolve;
|
|
185
|
+
let resolved = this.resolveImport(sourceFilePath, specifier.getLiteralValue(), specifiedFile);
|
|
186
|
+
if (!resolved) return;
|
|
187
|
+
if (onResolve) resolved = onResolve(resolved);
|
|
188
|
+
const out = writeReference(resolved);
|
|
189
|
+
if (out) specifier.setLiteralValue(out);
|
|
190
|
+
};
|
|
191
|
+
const sourceFile = await this.compiler.createSourceFile(sourceFilePath);
|
|
192
|
+
for (const item of sourceFile.getImportDeclarations()) process$1(item.getModuleSpecifier(), item.getModuleSpecifierSourceFile());
|
|
193
|
+
for (const item of sourceFile.getExportDeclarations()) {
|
|
194
|
+
const specifier = item.getModuleSpecifier();
|
|
195
|
+
if (!specifier) continue;
|
|
196
|
+
process$1(specifier, item.getModuleSpecifierSourceFile());
|
|
197
|
+
}
|
|
198
|
+
const calls = sourceFile.getDescendantsOfKind(ts.SyntaxKind.CallExpression);
|
|
199
|
+
for (const expression of calls) if (expression.getExpression().isKind(ts.SyntaxKind.ImportKeyword) && expression.getArguments().length === 1) {
|
|
200
|
+
const argument = expression.getArguments()[0];
|
|
201
|
+
if (!argument.isKind(ts.SyntaxKind.StringLiteral)) continue;
|
|
202
|
+
process$1(argument, argument.getSymbol()?.getDeclarations()[0].getSourceFile());
|
|
203
|
+
}
|
|
204
|
+
return {
|
|
205
|
+
content: sourceFile.getFullText(),
|
|
206
|
+
type: file.type,
|
|
207
|
+
path: file.path,
|
|
208
|
+
target: file.target
|
|
209
|
+
};
|
|
210
|
+
}
|
|
263
211
|
};
|
|
264
212
|
function resolveFromRemote(r, component, selectFile) {
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
213
|
+
const comp = r.components.find((comp$1) => comp$1.name === component);
|
|
214
|
+
if (!comp) return;
|
|
215
|
+
const file = comp.files.find(selectFile);
|
|
216
|
+
if (!file) return;
|
|
217
|
+
return {
|
|
218
|
+
type: "sub-component",
|
|
219
|
+
resolved: {
|
|
220
|
+
type: "remote",
|
|
221
|
+
registryName: r.name,
|
|
222
|
+
component: comp,
|
|
223
|
+
file
|
|
224
|
+
}
|
|
225
|
+
};
|
|
278
226
|
}
|
|
279
227
|
|
|
280
|
-
|
|
228
|
+
//#endregion
|
|
229
|
+
//#region src/build/index.ts
|
|
281
230
|
function combineRegistry(root, ...items) {
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
231
|
+
return {
|
|
232
|
+
...root,
|
|
233
|
+
info: {
|
|
234
|
+
...root.info,
|
|
235
|
+
registries: items.map((item) => item.name)
|
|
236
|
+
},
|
|
237
|
+
registries: items
|
|
238
|
+
};
|
|
290
239
|
}
|
|
291
240
|
async function writeFumadocsRegistry(out, options) {
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
for (const child of out.registries) {
|
|
313
|
-
write.push(
|
|
314
|
-
writeFumadocsRegistry(child, {
|
|
315
|
-
dir: path2.join(dir, child.name),
|
|
316
|
-
log: options.log
|
|
317
|
-
})
|
|
318
|
-
);
|
|
319
|
-
}
|
|
320
|
-
}
|
|
321
|
-
await Promise.all(write);
|
|
241
|
+
const { dir, cleanDir = false, log = true } = options;
|
|
242
|
+
if (cleanDir) {
|
|
243
|
+
await fs$1.rm(dir, {
|
|
244
|
+
recursive: true,
|
|
245
|
+
force: true
|
|
246
|
+
});
|
|
247
|
+
console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
|
|
248
|
+
}
|
|
249
|
+
async function writeInfo() {
|
|
250
|
+
await writeFile(path$1.join(dir, "_registry.json"), JSON.stringify(out.info, null, 2), log);
|
|
251
|
+
}
|
|
252
|
+
const write = out.components.map(async (comp) => {
|
|
253
|
+
await writeFile(path$1.join(dir, `${comp.name}.json`), JSON.stringify(comp, null, 2), log);
|
|
254
|
+
});
|
|
255
|
+
write.push(writeInfo());
|
|
256
|
+
if ("registries" in out) for (const child of out.registries) write.push(writeFumadocsRegistry(child, {
|
|
257
|
+
dir: path$1.join(dir, child.name),
|
|
258
|
+
log: options.log
|
|
259
|
+
}));
|
|
260
|
+
await Promise.all(write);
|
|
322
261
|
}
|
|
323
|
-
async function
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
);
|
|
331
|
-
}
|
|
262
|
+
async function writeFile(file, content, log = true) {
|
|
263
|
+
await fs$1.mkdir(path$1.dirname(file), { recursive: true });
|
|
264
|
+
await fs$1.writeFile(file, content);
|
|
265
|
+
if (log) {
|
|
266
|
+
const size = (Buffer.byteLength(content) / 1024).toFixed(2);
|
|
267
|
+
console.log(`${picocolors.greenBright("+")} ${path$1.relative(process.cwd(), file)} ${picocolors.dim(`${size} KB`)}`);
|
|
268
|
+
}
|
|
332
269
|
}
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
resolveFromRemote,
|
|
338
|
-
writeFumadocsRegistry
|
|
339
|
-
};
|
|
270
|
+
|
|
271
|
+
//#endregion
|
|
272
|
+
export { ComponentCompiler, RegistryCompiler, combineRegistry, resolveFromRemote, writeFumadocsRegistry };
|
|
273
|
+
//# sourceMappingURL=index.js.map
|