@hanzo/docs-cli 1.1.1 → 1.2.2

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 (10) hide show
  1. package/dist/build/index.d.ts +147 -149
  2. package/dist/build/index.d.ts.map +1 -0
  3. package/dist/build/index.js +260 -410
  4. package/dist/build/index.js.map +1 -0
  5. package/dist/index.d.ts +1 -1
  6. package/dist/index.js +581 -665
  7. package/dist/index.js.map +1 -0
  8. package/dist/schema/default.json +1 -0
  9. package/dist/schema/src.json +1 -0
  10. package/package.json +18 -18
package/dist/build/index.js CHANGED
@@ -1,423 +1,273 @@
1
- // src/build/index.ts
2
- import * as fs2 from "fs/promises";
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/shadcn.ts
7
- function mapDeps(deps) {
8
- return Object.entries(deps).map(([k, v]) => {
9
- if (v) return `${k}@${v}`;
10
- return k;
11
- });
12
- }
13
- function escapeName(name) {
14
- return name;
15
- }
16
- function toShadcnRegistry(out, baseUrl) {
17
- const registry = {
18
- homepage: baseUrl,
19
- name: out.name,
20
- items: out.components.map((comp) => componentToShadcn(comp, baseUrl))
21
- };
22
- return {
23
- registry,
24
- index: {
25
- ...registry,
26
- items: out.components.map(
27
- (comp) => componentToShadcn(comp, baseUrl, true)
28
- )
29
- }
30
- };
31
- }
32
- function componentToShadcn(comp, baseUrl, noFile = false) {
33
- const FileType = {
34
- components: "registry:component",
35
- lib: "registry:lib",
36
- css: "registry:style",
37
- route: "registry:page",
38
- ui: "registry:ui",
39
- block: "registry:block"
40
- };
41
- function onFile(file) {
42
- return {
43
- type: FileType[file.type],
44
- content: file.content,
45
- path: file.path,
46
- target: file.target
47
- };
48
- }
49
- return {
50
- extends: "none",
51
- type: "registry:block",
52
- name: escapeName(comp.name),
53
- title: comp.title ?? comp.name,
54
- description: comp.description,
55
- dependencies: mapDeps(comp.dependencies),
56
- devDependencies: mapDeps(comp.devDependencies),
57
- registryDependencies: comp.subComponents?.map((comp2) => {
58
- if (comp2.startsWith("https://") || comp2.startsWith("http://"))
59
- return comp2;
60
- return new URL(`/r/${escapeName(comp2)}.json`, baseUrl).toString();
61
- }),
62
- files: noFile ? [] : comp.files.map(onFile)
63
- };
64
- }
65
-
66
- // src/build/validate.ts
67
- function validateOutput(registry) {
68
- const validatedComps = /* @__PURE__ */ new Set();
69
- const fileToComps = /* @__PURE__ */ new Map();
70
- function validateComponent(comp) {
71
- if (validatedComps.has(comp.name)) return;
72
- validatedComps.add(comp.name);
73
- for (const file of comp.files) {
74
- const parents = fileToComps.get(file.path);
75
- if (parents) {
76
- parents.add(comp.name);
77
- } else {
78
- fileToComps.set(file.path, /* @__PURE__ */ new Set([comp.name]));
79
- }
80
- }
81
- for (const name of comp.subComponents ?? []) {
82
- const subComp = registry.components.find((item) => item.name === name);
83
- if (!subComp) {
84
- console.warn(`skipped component ${name}: not found`);
85
- continue;
86
- }
87
- validateComponent(subComp);
88
- }
89
- for (const file of comp.files) {
90
- const parents = fileToComps.get(file.path);
91
- if (!parents || parents.size <= 1) continue;
92
- throw new Error(
93
- `Duplicated file in same component ${Array.from(parents).join(", ")}: ${file.path}`
94
- );
95
- }
96
- }
97
- for (const comp of registry.components) {
98
- fileToComps.clear();
99
- validateComponent(comp);
100
- }
101
- }
102
-
103
- // src/build/compiler.ts
104
- import * as fs from "fs/promises";
105
- import * as path from "path";
106
4
  import { Project, ts } from "ts-morph";
5
+
6
+ //#region src/build/compiler.ts
107
7
  var RegistryCompiler = class {
108
- constructor(registry) {
109
- this.raw = registry;
110
- this.project = new Project({
111
- tsConfigFilePath: path.join(registry.dir, registry.tsconfigPath)
112
- });
113
- }
114
- async readPackageJson() {
115
- if (typeof this.raw.packageJson !== "string") return this.raw.packageJson;
116
- return fs.readFile(path.join(this.raw.dir, this.raw.packageJson)).then((res) => JSON.parse(res.toString())).catch(() => void 0);
117
- }
118
- async createSourceFile(file) {
119
- const content = await fs.readFile(file);
120
- return this.project.createSourceFile(file, content.toString(), {
121
- overwrite: true
122
- });
123
- }
124
- async compile() {
125
- const registry = this.raw;
126
- this.resolver = new RegistryResolver(this, await this.readPackageJson());
127
- const output = {
128
- name: registry.name,
129
- index: [],
130
- components: [],
131
- switchables: registry.switchables
132
- };
133
- const builtComps = await Promise.all(
134
- registry.components.map(async (component) => {
135
- const compiler = new ComponentCompiler(this, component);
136
- return [component, await compiler.build()];
137
- })
138
- );
139
- for (const [input, comp] of builtComps) {
140
- if (!input.unlisted) {
141
- output.index.push({
142
- name: input.name,
143
- title: input.title,
144
- description: input.description
145
- });
146
- }
147
- output.components.push(comp);
148
- }
149
- return output;
150
- }
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
+ }
151
45
  };
152
46
  var RegistryResolver = class {
153
- constructor(compiler, packageJson = {}) {
154
- this.compiler = compiler;
155
- this.fileToComponent = /* @__PURE__ */ new Map();
156
- const registry = compiler.raw;
157
- for (const comp of registry.components) {
158
- for (const file of comp.files) {
159
- if (this.fileToComponent.has(file.path))
160
- console.warn(
161
- `the same file ${file.path} exists in multiple component, you should make the shared file a separate component.`
162
- );
163
- this.fileToComponent.set(file.path, [comp, file]);
164
- }
165
- }
166
- this.deps = {
167
- ...packageJson?.dependencies,
168
- ...registry.dependencies
169
- };
170
- this.devDeps = {
171
- ...packageJson?.devDependencies,
172
- ...registry.devDependencies
173
- };
174
- }
175
- getDepFromSpecifier(specifier) {
176
- return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
177
- }
178
- getDepInfo(name) {
179
- if (name in this.deps)
180
- return {
181
- name,
182
- type: "runtime",
183
- version: this.deps[name]
184
- };
185
- if (name in this.devDeps)
186
- return {
187
- name,
188
- type: "dev",
189
- version: this.devDeps[name]
190
- };
191
- console.warn(`dep info for ${name} cannot be found`);
192
- }
193
- getComponentByName(name) {
194
- return this.compiler.raw.components.find((comp) => comp.name === name);
195
- }
196
- getSubComponent(file) {
197
- const relativeFile = path.relative(this.compiler.raw.dir, file);
198
- const comp = this.fileToComponent.get(relativeFile);
199
- if (!comp) return;
200
- return {
201
- component: comp[0],
202
- file: comp[1]
203
- };
204
- }
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
+ }
205
92
  };
206
93
  var ComponentCompiler = class {
207
- constructor(compiler, component) {
208
- this.compiler = compiler;
209
- this.component = component;
210
- this.processedFiles = /* @__PURE__ */ new Set();
211
- this.subComponents = /* @__PURE__ */ new Set();
212
- this.devDependencies = /* @__PURE__ */ new Map();
213
- this.dependencies = /* @__PURE__ */ new Map();
214
- this.registry = compiler.raw;
215
- }
216
- // see https://github.com/shadcn-ui/ui/blob/396275e46a58333caa1fa0a991bd9bc5237d2ee3/packages/shadcn/src/utils/updaters/update-files.ts#L585
217
- // to hit the fast-path step, we need to import `target` path first because it's detected from `fileSet`, a set of output file paths
218
- toImportPath(file) {
219
- let filePath = file.target ?? file.path;
220
- if (filePath.startsWith("./")) filePath = filePath.slice(2);
221
- return `@/${filePath.replaceAll(path.sep, "/")}`;
222
- }
223
- async build() {
224
- return {
225
- name: this.component.name,
226
- title: this.component.title,
227
- description: this.component.description,
228
- files: (await Promise.all(
229
- this.component.files.map((file) => this.buildFileAndDeps(file))
230
- )).flat(),
231
- subComponents: Array.from(this.subComponents),
232
- dependencies: Object.fromEntries(this.dependencies),
233
- devDependencies: Object.fromEntries(this.devDependencies)
234
- };
235
- }
236
- async buildFileAndDeps(file) {
237
- if (this.processedFiles.has(file.path)) return [];
238
- this.processedFiles.add(file.path);
239
- const resolver = this.compiler.resolver;
240
- const queue = [];
241
- const result = await this.buildFile(file, (reference) => {
242
- if (reference.type === "custom") return reference.specifier;
243
- if (reference.type === "file") {
244
- const refFile = this.registry.onUnknownFile?.(reference.file);
245
- if (refFile) {
246
- queue.push(refFile);
247
- return this.toImportPath(refFile);
248
- }
249
- if (refFile === false) return;
250
- throw new Error(
251
- `Unknown file ${reference.file} referenced by ${file.path}`
252
- );
253
- }
254
- if (reference.type === "sub-component") {
255
- const resolved = reference.resolved;
256
- if (resolved.component.name !== this.component.name) {
257
- this.subComponents.add(resolved.component.name);
258
- }
259
- return this.toImportPath(resolved.file);
260
- }
261
- const dep = resolver.getDepInfo(reference.dep);
262
- if (dep) {
263
- const map = dep.type === "dev" ? this.devDependencies : this.dependencies;
264
- map.set(dep.name, dep.version);
265
- }
266
- return reference.specifier;
267
- });
268
- return [
269
- result,
270
- ...(await Promise.all(queue.map((file2) => this.buildFileAndDeps(file2)))).flat()
271
- ];
272
- }
273
- resolveImport(sourceFilePath, specifier, specified) {
274
- let filePath;
275
- if (specified) {
276
- filePath = specified.getFilePath();
277
- } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
278
- filePath = path.join(path.dirname(sourceFilePath), specifier);
279
- } else {
280
- if (!specifier.startsWith("node:"))
281
- console.warn(`Unknown specifier ${specifier}, skipping for now`);
282
- return;
283
- }
284
- const resolver = this.compiler.resolver;
285
- if (path.relative(this.registry.dir, filePath).startsWith("../")) {
286
- return {
287
- type: "dependency",
288
- dep: resolver.getDepFromSpecifier(specifier),
289
- specifier
290
- };
291
- }
292
- const sub = resolver.getSubComponent(filePath);
293
- if (sub) {
294
- return {
295
- type: "sub-component",
296
- resolved: {
297
- type: "local",
298
- component: sub.component,
299
- file: sub.file
300
- }
301
- };
302
- }
303
- return {
304
- type: "file",
305
- file: filePath
306
- };
307
- }
308
- async buildFile(file, writeReference) {
309
- const sourceFilePath = path.join(this.registry.dir, file.path);
310
- const process2 = (specifier, specifiedFile) => {
311
- const onResolve = this.component.onResolve ?? this.registry.onResolve;
312
- let resolved = this.resolveImport(
313
- sourceFilePath,
314
- specifier.getLiteralValue(),
315
- specifiedFile
316
- );
317
- if (!resolved) return;
318
- if (onResolve) resolved = onResolve(resolved);
319
- const out = writeReference(resolved);
320
- if (out) specifier.setLiteralValue(out);
321
- };
322
- const sourceFile = await this.compiler.createSourceFile(sourceFilePath);
323
- for (const item of sourceFile.getImportDeclarations()) {
324
- process2(item.getModuleSpecifier(), item.getModuleSpecifierSourceFile());
325
- }
326
- for (const item of sourceFile.getExportDeclarations()) {
327
- const specifier = item.getModuleSpecifier();
328
- if (!specifier) continue;
329
- process2(specifier, item.getModuleSpecifierSourceFile());
330
- }
331
- const calls = sourceFile.getDescendantsOfKind(ts.SyntaxKind.CallExpression);
332
- for (const expression of calls) {
333
- if (expression.getExpression().isKind(ts.SyntaxKind.ImportKeyword) && expression.getArguments().length === 1) {
334
- const argument = expression.getArguments()[0];
335
- if (!argument.isKind(ts.SyntaxKind.StringLiteral)) continue;
336
- process2(
337
- argument,
338
- argument.getSymbol()?.getDeclarations()[0].getSourceFile()
339
- );
340
- }
341
- }
342
- return {
343
- content: sourceFile.getFullText(),
344
- type: file.type,
345
- path: file.path,
346
- target: file.target
347
- };
348
- }
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
+ }
349
211
  };
350
-
351
- // src/build/index.ts
352
- function combineRegistry(...items) {
353
- const out = {
354
- index: [],
355
- components: [],
356
- name: items[0].name
357
- };
358
- for (const item of items) {
359
- out.components.push(...item.components);
360
- out.index.push(...item.index);
361
- }
362
- validateOutput(out);
363
- return out;
212
+ function resolveFromRemote(r, component, selectFile) {
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
+ };
364
226
  }
365
- async function writeShadcnRegistry(out, options) {
366
- const { dir, cleanDir = false, baseUrl } = options;
367
- if (cleanDir) {
368
- await fs2.rm(dir, {
369
- recursive: true,
370
- force: true
371
- });
372
- console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
373
- }
374
- const { registry, index } = toShadcnRegistry(out, baseUrl);
375
- const write = registry.items.map(async (item) => {
376
- const file = path2.join(dir, `${item.name}.json`);
377
- await writeFile2(file, JSON.stringify(item, null, 2));
378
- });
379
- write.push(
380
- writeFile2(path2.join(dir, "registry.json"), JSON.stringify(index, null, 2))
381
- );
382
- await Promise.all(write);
227
+
228
+ //#endregion
229
+ //#region src/build/index.ts
230
+ function combineRegistry(root, ...items) {
231
+ return {
232
+ ...root,
233
+ info: {
234
+ ...root.info,
235
+ registries: items.map((item) => item.name)
236
+ },
237
+ registries: items
238
+ };
383
239
  }
384
240
  async function writeFumadocsRegistry(out, options) {
385
- const { dir, cleanDir = false, log = true } = options;
386
- if (cleanDir) {
387
- await fs2.rm(dir, {
388
- recursive: true,
389
- force: true
390
- });
391
- console.log(picocolors.bold(picocolors.greenBright("Cleaned directory")));
392
- }
393
- async function writeIndex() {
394
- const file = path2.join(dir, "_registry.json");
395
- const json = JSON.stringify(out.index, null, 2);
396
- await writeFile2(file, json, log);
397
- }
398
- const write = out.components.map(async (comp) => {
399
- const file = path2.join(dir, `${comp.name}.json`);
400
- const json = JSON.stringify(comp, null, 2);
401
- await writeFile2(file, json, log);
402
- });
403
- write.push(writeIndex());
404
- 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);
405
261
  }
406
- async function writeFile2(file, content, log = true) {
407
- await fs2.mkdir(path2.dirname(file), { recursive: true });
408
- await fs2.writeFile(file, content);
409
- if (log) {
410
- const size = (Buffer.byteLength(content) / 1024).toFixed(2);
411
- console.log(
412
- `${picocolors.greenBright("+")} ${path2.relative(process.cwd(), file)} ${picocolors.dim(`${size} KB`)}`
413
- );
414
- }
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
+ }
415
269
  }
416
- export {
417
- ComponentCompiler,
418
- RegistryCompiler,
419
- combineRegistry,
420
- toShadcnRegistry,
421
- writeFumadocsRegistry,
422
- writeShadcnRegistry
423
- };
270
+
271
+ //#endregion
272
+ export { ComponentCompiler, RegistryCompiler, combineRegistry, resolveFromRemote, writeFumadocsRegistry };
273
+ //# sourceMappingURL=index.js.map