@matizze/prumo-cli 0.0.0-stage → 0.5.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/README.md +121 -2
- package/dist/api.d.ts +10 -0
- package/dist/api.js +9 -0
- package/dist/args.d.ts +11 -0
- package/dist/args.js +61 -0
- package/dist/bin.d.ts +2 -0
- package/dist/bin.js +11 -0
- package/dist/codemod/add-route.d.ts +66 -0
- package/dist/codemod/add-route.js +435 -0
- package/dist/codemod/edit.d.ts +35 -0
- package/dist/codemod/edit.js +51 -0
- package/dist/codemod/index.d.ts +8 -0
- package/dist/codemod/index.js +8 -0
- package/dist/codemod/merge-barrel.d.ts +9 -0
- package/dist/codemod/merge-barrel.js +49 -0
- package/dist/codemod/messages.d.ts +11 -0
- package/dist/codemod/messages.js +46 -0
- package/dist/codemod/names.d.ts +62 -0
- package/dist/codemod/names.js +204 -0
- package/dist/codemod/plan.d.ts +45 -0
- package/dist/codemod/plan.js +147 -0
- package/dist/codemod/register-domain.d.ts +51 -0
- package/dist/codemod/register-domain.js +237 -0
- package/dist/codemod/register-messages.d.ts +11 -0
- package/dist/codemod/register-messages.js +112 -0
- package/dist/codemod/route-elements.d.ts +25 -0
- package/dist/codemod/route-elements.js +72 -0
- package/dist/commands/check.d.ts +16 -0
- package/dist/commands/check.js +47 -0
- package/dist/commands/doctor.d.ts +20 -0
- package/dist/commands/doctor.js +87 -0
- package/dist/commands/make-component.d.ts +33 -0
- package/dist/commands/make-component.js +85 -0
- package/dist/commands/make-domain.d.ts +30 -0
- package/dist/commands/make-domain.js +83 -0
- package/dist/commands/make-page.d.ts +30 -0
- package/dist/commands/make-page.js +73 -0
- package/dist/commands/new.d.ts +33 -0
- package/dist/commands/new.js +184 -0
- package/dist/commands/shared.d.ts +43 -0
- package/dist/commands/shared.js +83 -0
- package/dist/describe.d.ts +63 -0
- package/dist/describe.js +134 -0
- package/dist/doctor/checks.d.ts +35 -0
- package/dist/doctor/checks.js +283 -0
- package/dist/doctor/ranges.d.ts +16 -0
- package/dist/doctor/ranges.js +27 -0
- package/dist/doctor/versions.d.ts +33 -0
- package/dist/doctor/versions.js +44 -0
- package/dist/errors.d.ts +12 -0
- package/dist/errors.js +19 -0
- package/dist/generate/app.d.ts +29 -0
- package/dist/generate/app.js +137 -0
- package/dist/generate/component.d.ts +36 -0
- package/dist/generate/component.js +48 -0
- package/dist/generate/domain.d.ts +31 -0
- package/dist/generate/domain.js +63 -0
- package/dist/generate/page.d.ts +45 -0
- package/dist/generate/page.js +100 -0
- package/dist/help.d.ts +19 -0
- package/dist/help.js +97 -0
- package/dist/in-process.d.ts +26 -0
- package/dist/in-process.js +23 -0
- package/dist/index.d.ts +9 -0
- package/dist/index.js +9 -0
- package/dist/new/name.d.ts +7 -0
- package/dist/new/name.js +24 -0
- package/dist/new/packages.d.ts +6 -0
- package/dist/new/packages.js +40 -0
- package/dist/new/versions.d.ts +7 -0
- package/dist/new/versions.js +13 -0
- package/dist/pnpm.d.ts +14 -0
- package/dist/pnpm.js +37 -0
- package/dist/process.d.ts +22 -0
- package/dist/process.js +45 -0
- package/dist/project.d.ts +22 -0
- package/dist/project.js +42 -0
- package/dist/root.d.ts +3 -0
- package/dist/root.js +24 -0
- package/dist/run.d.ts +13 -0
- package/dist/run.js +72 -0
- package/dist/runtime.d.ts +19 -0
- package/dist/runtime.js +1 -0
- package/dist/templates.d.ts +26 -0
- package/dist/templates.js +46 -0
- package/package.json +45 -3
- package/templates/app/AGENTS.md.tpl +50 -0
- package/templates/app/README.md.tpl +15 -0
- package/templates/app/eslint.config.js.tpl +19 -0
- package/templates/app/gitignore.tpl +22 -0
- package/templates/app/index.html.tpl +12 -0
- package/templates/app/mcp.json.tpl +8 -0
- package/templates/app/src/App.tsx.tpl +8 -0
- package/templates/app/src/i18n.ts.tpl +12 -0
- package/templates/app/src/main.tsx.tpl +12 -0
- package/templates/app/src/messages/index.ts.tpl +1 -0
- package/templates/app/src/providers/app.tsx.tpl +23 -0
- package/templates/app/src/providers/repository/index.ts.tpl +5 -0
- package/templates/app/src/queries-index.ts.tpl +1 -0
- package/templates/app/src/repositories/index.ts.tpl +18 -0
- package/templates/app/src/repositories/options.ts.tpl +8 -0
- package/templates/app/src/schemas-index.ts.tpl +1 -0
- package/templates/app/src/test/render.tsx.tpl +31 -0
- package/templates/app/src/test/setup.ts.tpl +4 -0
- package/templates/app/typescript.json.tpl +24 -0
- package/templates/app/vite.config.ts.tpl +16 -0
- package/templates/component/component-test.tsx.tpl +9 -0
- package/templates/component/component.tsx.tpl +11 -0
- package/templates/domain/queries.ts.tpl +62 -0
- package/templates/domain/repository-contract-test.ts.tpl +75 -0
- package/templates/domain/repository-contract.ts.tpl +13 -0
- package/templates/domain/repository-fixtures.ts.tpl +8 -0
- package/templates/domain/repository-index.ts.tpl +12 -0
- package/templates/domain/repository-mock.ts.tpl +69 -0
- package/templates/domain/schema.ts.tpl +23 -0
- package/templates/page/index-domain-test.tsx.tpl +11 -0
- package/templates/page/index-test.tsx.tpl +10 -0
- package/templates/page/index.tsx.tpl +7 -0
- package/templates/page/messages-domain.en.json.tpl +5 -0
- package/templates/page/messages-domain.pt-BR.json.tpl +5 -0
- package/templates/page/messages.en.json.tpl +3 -0
- package/templates/page/messages.pt-BR.json.tpl +3 -0
- package/templates/page/model-domain.ts.tpl +17 -0
- package/templates/page/model.ts.tpl +8 -0
- package/templates/page/view-domain.tsx.tpl +20 -0
- package/templates/page/view.tsx.tpl +9 -0
package/dist/help.js
ADDED
|
@@ -0,0 +1,97 @@
|
|
|
1
|
+
/** Resolve o que o citty aceita como valor, função ou promessa. */
|
|
2
|
+
export async function resolveValue(value) {
|
|
3
|
+
return typeof value === 'function' ? await value() : await value;
|
|
4
|
+
}
|
|
5
|
+
/** A primeira linha da descrição, que é o resumo mostrado na lista de comandos. */
|
|
6
|
+
export function summary(description) {
|
|
7
|
+
return (description ?? '').split('\n')[0] ?? '';
|
|
8
|
+
}
|
|
9
|
+
/**
|
|
10
|
+
* A ajuda de um comando, em português: a sintaxe, a descrição, os argumentos, as opções e, para um
|
|
11
|
+
* comando com subcomandos, a lista deles. O citty tem uma ajuda própria, mas ela é em inglês e
|
|
12
|
+
* não permite trocar os títulos. `path` é o caminho do comando, como `['prumo', 'check']`.
|
|
13
|
+
*/
|
|
14
|
+
export async function renderHelp(command, path) {
|
|
15
|
+
const meta = await resolveValue(command.meta ?? {});
|
|
16
|
+
const args = Object.entries(await resolveValue(command.args ?? {}));
|
|
17
|
+
const subCommands = Object.entries(await resolveValue(command.subCommands ?? {}));
|
|
18
|
+
const positionals = args.filter(([, def]) => def.type === 'positional');
|
|
19
|
+
const options = args.filter(([, def]) => def.type !== 'positional');
|
|
20
|
+
const syntax = [path.join(' ')];
|
|
21
|
+
if (subCommands.length > 0)
|
|
22
|
+
syntax.push('<comando> [opções]');
|
|
23
|
+
for (const [name, def] of positionals)
|
|
24
|
+
syntax.push(positionalText(name, def));
|
|
25
|
+
for (const [name, def] of options) {
|
|
26
|
+
const text = `${flagOf(name, def)}${valueOf(name, def)}`;
|
|
27
|
+
syntax.push(isRequired(def) ? text : `[${text}]`);
|
|
28
|
+
}
|
|
29
|
+
const sections = [`Uso: ${syntax.join(' ')}`];
|
|
30
|
+
if (meta.description)
|
|
31
|
+
sections.push(meta.description);
|
|
32
|
+
if (positionals.length > 0) {
|
|
33
|
+
sections.push(`Argumentos:\n${columns(positionals.map(([name, def]) => [name, def.description ?? '']))}`);
|
|
34
|
+
}
|
|
35
|
+
const optionRows = options.map(([name, def]) => [optionLabel(name, def), def.description ?? '']);
|
|
36
|
+
if (subCommands.length === 0)
|
|
37
|
+
optionRows.push(['-h, --help', 'Mostra esta ajuda.']);
|
|
38
|
+
if (optionRows.length > 0)
|
|
39
|
+
sections.push(`Opções:\n${columns(optionRows)}`);
|
|
40
|
+
if (subCommands.length > 0) {
|
|
41
|
+
const rows = [];
|
|
42
|
+
for (const [name, sub] of subCommands) {
|
|
43
|
+
const subMeta = await resolveValue((await resolveValue(sub)).meta ?? {});
|
|
44
|
+
if (!subMeta.hidden)
|
|
45
|
+
rows.push([name, summary(subMeta.description)]);
|
|
46
|
+
}
|
|
47
|
+
sections.push(`Comandos:\n${columns(rows)}`);
|
|
48
|
+
sections.push(`Rode "${path.join(' ')} <comando> --help" para ver as opções de um comando.`);
|
|
49
|
+
}
|
|
50
|
+
return sections.join('\n\n');
|
|
51
|
+
}
|
|
52
|
+
/** O argumento posicional que aceita vários valores: o nome termina em `...` (`item...`). */
|
|
53
|
+
export function isVariadic(name) {
|
|
54
|
+
return name?.endsWith('...') ?? false;
|
|
55
|
+
}
|
|
56
|
+
/** O argumento posicional na sintaxe: `<nome>`, `[nome]` se opcional, e `<item>...` se aceita vários. */
|
|
57
|
+
function positionalText(name, def) {
|
|
58
|
+
const text = isVariadic(name) ? `${name.slice(0, -3)}` : name;
|
|
59
|
+
const wrapped = isRequired(def) ? `<${text}>` : `[${text}]`;
|
|
60
|
+
return isVariadic(name) ? `${wrapped}...` : wrapped;
|
|
61
|
+
}
|
|
62
|
+
/** Os apelidos da opção (`-h` de `--help`). O argumento posicional não tem. */
|
|
63
|
+
export function aliasesOf(def) {
|
|
64
|
+
return 'alias' in def ? [def.alias ?? []].flat() : [];
|
|
65
|
+
}
|
|
66
|
+
/** Se o argumento é obrigatório: o posicional é, a não ser que diga o contrário; a opção só se disser. */
|
|
67
|
+
export function isRequired(def) {
|
|
68
|
+
return (def.default === undefined &&
|
|
69
|
+
(def.type === 'positional' ? def.required !== false : !!def.required));
|
|
70
|
+
}
|
|
71
|
+
/** O valor da opção na sintaxe: ` <pasta>`, ou nada para a opção que é só liga e desliga. */
|
|
72
|
+
function valueOf(name, def) {
|
|
73
|
+
if (def.type === 'boolean')
|
|
74
|
+
return '';
|
|
75
|
+
if (def.type === 'enum' && def.options?.length)
|
|
76
|
+
return ` <${def.options.join('|')}>`;
|
|
77
|
+
return ` <${def.valueHint ?? name}>`;
|
|
78
|
+
}
|
|
79
|
+
function optionLabel(name, def) {
|
|
80
|
+
const aliases = aliasesOf(def).map((alias) => `-${alias}`);
|
|
81
|
+
return [...aliases, flagOf(name, def)].join(', ') + valueOf(name, def);
|
|
82
|
+
}
|
|
83
|
+
/**
|
|
84
|
+
* A opção como se escreve na linha de comando. A opção liga e desliga que já vem ligada
|
|
85
|
+
* (`default: true`) só se desliga, e o citty entende `--no-<nome>` como `<nome>: false`: é esse o
|
|
86
|
+
* nome que a ajuda mostra (`--no-install`, para a opção `install`).
|
|
87
|
+
*/
|
|
88
|
+
function flagOf(name, def) {
|
|
89
|
+
return def.type === 'boolean' && def.default === true ? `--no-${name}` : `--${name}`;
|
|
90
|
+
}
|
|
91
|
+
/** Duas colunas alinhadas, recuadas em dois espaços. */
|
|
92
|
+
function columns(rows) {
|
|
93
|
+
const width = Math.max(...rows.map(([label]) => label?.length ?? 0));
|
|
94
|
+
return rows
|
|
95
|
+
.map(([label = '', text = '']) => ` ${label.padEnd(width)} ${text}`.trimEnd())
|
|
96
|
+
.join('\n');
|
|
97
|
+
}
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
/** Onde e com que ambiente o comando roda em processo. */
|
|
2
|
+
export interface InProcessOptions {
|
|
3
|
+
/** A pasta de trabalho do comando: quem chama passa, o `process.cwd()` não é lido. */
|
|
4
|
+
cwd: string;
|
|
5
|
+
/** As variáveis de ambiente do comando. Padrão: nenhuma. */
|
|
6
|
+
env?: Readonly<Record<string, string | undefined>>;
|
|
7
|
+
}
|
|
8
|
+
/** O resultado de um comando rodado em processo. */
|
|
9
|
+
export interface InProcessResult {
|
|
10
|
+
/** O código de saída: 0 sem erro, 1 para falha ou violação, 2 para uso errado. */
|
|
11
|
+
exitCode: number;
|
|
12
|
+
/** O que o comando escreveu no stdout, inclusive a saída capturada dos subprocessos dele. */
|
|
13
|
+
stdout: string;
|
|
14
|
+
/** O que o comando escreveu no stderr. */
|
|
15
|
+
stderr: string;
|
|
16
|
+
}
|
|
17
|
+
/**
|
|
18
|
+
* Roda um comando do `prumo` neste processo e devolve o código de saída e a saída, sem escrever no
|
|
19
|
+
* stdout nem no stderr do processo (num servidor MCP o stdout é o protocolo) e sem encerrar nada.
|
|
20
|
+
* `argv` é a linha de comando sem o `prumo` (`['check', '--root=app']`); a de
|
|
21
|
+
* um comando descrito é `[...command.path, ...toArgv(command, input)]`.
|
|
22
|
+
*
|
|
23
|
+
* O Runtime é de captura: nada é lido do processo (`cwd`, `env`), e duas chamadas não compartilham
|
|
24
|
+
* estado.
|
|
25
|
+
*/
|
|
26
|
+
export declare function runInProcess(argv: string[], options: InProcessOptions): Promise<InProcessResult>;
|
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
import { createRoot } from "./root.js";
|
|
2
|
+
import { runCli } from "./run.js";
|
|
3
|
+
/**
|
|
4
|
+
* Roda um comando do `prumo` neste processo e devolve o código de saída e a saída, sem escrever no
|
|
5
|
+
* stdout nem no stderr do processo (num servidor MCP o stdout é o protocolo) e sem encerrar nada.
|
|
6
|
+
* `argv` é a linha de comando sem o `prumo` (`['check', '--root=app']`); a de
|
|
7
|
+
* um comando descrito é `[...command.path, ...toArgv(command, input)]`.
|
|
8
|
+
*
|
|
9
|
+
* O Runtime é de captura: nada é lido do processo (`cwd`, `env`), e duas chamadas não compartilham
|
|
10
|
+
* estado.
|
|
11
|
+
*/
|
|
12
|
+
export async function runInProcess(argv, options) {
|
|
13
|
+
let stdout = '';
|
|
14
|
+
let stderr = '';
|
|
15
|
+
const runtime = {
|
|
16
|
+
out: (text) => void (stdout += text),
|
|
17
|
+
err: (text) => void (stderr += text),
|
|
18
|
+
cwd: options.cwd,
|
|
19
|
+
env: options.env ?? {},
|
|
20
|
+
};
|
|
21
|
+
const exitCode = await runCli(createRoot(runtime), argv, runtime);
|
|
22
|
+
return { exitCode, stdout, stderr };
|
|
23
|
+
}
|
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Ponto de entrada do @matizze/prumo-cli.
|
|
3
|
+
*
|
|
4
|
+
* O conteúdo do pacote é o comando `prumo`, o bin em `src/bin.ts`, montado pelo `src/root.ts`, que
|
|
5
|
+
* lista os comandos. A API em processo (rodar um comando e descrever a árvore) está em `src/api.ts`,
|
|
6
|
+
* reexportada aqui e publicada também como `@matizze/prumo-cli/api`.
|
|
7
|
+
*/
|
|
8
|
+
export declare const PACKAGE_NAME = "@matizze/prumo-cli";
|
|
9
|
+
export * from './api.js';
|
package/dist/index.js
ADDED
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Ponto de entrada do @matizze/prumo-cli.
|
|
3
|
+
*
|
|
4
|
+
* O conteúdo do pacote é o comando `prumo`, o bin em `src/bin.ts`, montado pelo `src/root.ts`, que
|
|
5
|
+
* lista os comandos. A API em processo (rodar um comando e descrever a árvore) está em `src/api.ts`,
|
|
6
|
+
* reexportada aqui e publicada também como `@matizze/prumo-cli/api`.
|
|
7
|
+
*/
|
|
8
|
+
export const PACKAGE_NAME = '@matizze/prumo-cli';
|
|
9
|
+
export * from "./api.js";
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Confere o nome do app, que vira o nome da pasta e o `name` do `package.json`. Devolve o motivo,
|
|
3
|
+
* em português, se o nome não serve, ou `undefined` se serve.
|
|
4
|
+
*/
|
|
5
|
+
export declare function appNameProblem(name: string): string | undefined;
|
|
6
|
+
/** O nome para ler: `meu-app` vira `Meu App` (título do `index.html` e do `AGENTS.md`). */
|
|
7
|
+
export declare function titleOf(name: string): string;
|
package/dist/new/name.js
ADDED
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
/** O tamanho máximo de um nome de pacote no npm. */
|
|
2
|
+
const MAX_LENGTH = 214;
|
|
3
|
+
/** kebab-case que começa com letra: `meu-produto`, `loja2`, `app`. */
|
|
4
|
+
const KEBAB_CASE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
|
|
5
|
+
/**
|
|
6
|
+
* Confere o nome do app, que vira o nome da pasta e o `name` do `package.json`. Devolve o motivo,
|
|
7
|
+
* em português, se o nome não serve, ou `undefined` se serve.
|
|
8
|
+
*/
|
|
9
|
+
export function appNameProblem(name) {
|
|
10
|
+
if (name.length > MAX_LENGTH) {
|
|
11
|
+
return `o nome '${name}' é longo demais para um pacote (no máximo ${MAX_LENGTH} caracteres).`;
|
|
12
|
+
}
|
|
13
|
+
if (!KEBAB_CASE.test(name)) {
|
|
14
|
+
return `o nome '${name}' precisa estar em kebab-case, começar com letra e ter só letras minúsculas, números e hífens (por exemplo, meu-app).`;
|
|
15
|
+
}
|
|
16
|
+
return undefined;
|
|
17
|
+
}
|
|
18
|
+
/** O nome para ler: `meu-app` vira `Meu App` (título do `index.html` e do `AGENTS.md`). */
|
|
19
|
+
export function titleOf(name) {
|
|
20
|
+
return name
|
|
21
|
+
.split('-')
|
|
22
|
+
.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
|
|
23
|
+
.join(' ');
|
|
24
|
+
}
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Os tarballs `.tgz` dos pacotes do Prumo de uma pasta (a que o `pnpm pack:all` gera), como um mapa
|
|
3
|
+
* de nome do pacote para o `file:` do caminho absoluto. Um tarball de outro pacote é ignorado. Pasta
|
|
4
|
+
* que não existe, ou sem o tarball de algum dos pacotes que o app instala, é erro de uso.
|
|
5
|
+
*/
|
|
6
|
+
export declare function readTarballs(dir: string): Record<string, string>;
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
import { spawnSync } from 'node:child_process';
|
|
2
|
+
import { existsSync, readdirSync, statSync } from 'node:fs';
|
|
3
|
+
import path from 'node:path';
|
|
4
|
+
import { UsageError } from "../errors.js";
|
|
5
|
+
import { PRUMO_VERSIONS } from "./versions.js";
|
|
6
|
+
/** O nome e a versão do pacote dentro de um tarball, lidos com o `tar` do sistema. */
|
|
7
|
+
function readTarballName(file) {
|
|
8
|
+
const result = spawnSync('tar', ['-xOzf', file, 'package/package.json'], { encoding: 'utf8' });
|
|
9
|
+
if (result.error || result.status !== 0) {
|
|
10
|
+
throw new UsageError(`não consegui ler o package.json de '${file}' (--packages): ${result.error?.message ?? result.stderr.trim()}`);
|
|
11
|
+
}
|
|
12
|
+
const { name } = JSON.parse(result.stdout);
|
|
13
|
+
if (!name)
|
|
14
|
+
throw new UsageError(`o tarball '${file}' não tem nome no package.json (--packages).`);
|
|
15
|
+
return name;
|
|
16
|
+
}
|
|
17
|
+
/**
|
|
18
|
+
* Os tarballs `.tgz` dos pacotes do Prumo de uma pasta (a que o `pnpm pack:all` gera), como um mapa
|
|
19
|
+
* de nome do pacote para o `file:` do caminho absoluto. Um tarball de outro pacote é ignorado. Pasta
|
|
20
|
+
* que não existe, ou sem o tarball de algum dos pacotes que o app instala, é erro de uso.
|
|
21
|
+
*/
|
|
22
|
+
export function readTarballs(dir) {
|
|
23
|
+
if (!existsSync(dir) || !statSync(dir).isDirectory()) {
|
|
24
|
+
throw new UsageError(`a pasta '${dir}' não existe (--packages).`);
|
|
25
|
+
}
|
|
26
|
+
const tarballs = {};
|
|
27
|
+
for (const entry of readdirSync(dir).sort()) {
|
|
28
|
+
if (!entry.endsWith('.tgz'))
|
|
29
|
+
continue;
|
|
30
|
+
const file = path.join(dir, entry);
|
|
31
|
+
const name = readTarballName(file);
|
|
32
|
+
if (name in PRUMO_VERSIONS)
|
|
33
|
+
tarballs[name] = `file:${file}`;
|
|
34
|
+
}
|
|
35
|
+
const missing = Object.keys(PRUMO_VERSIONS).filter((name) => !(name in tarballs));
|
|
36
|
+
if (missing.length > 0) {
|
|
37
|
+
throw new UsageError(`a pasta '${dir}' não tem o tarball de ${missing.join(', ')} (--packages). Gere-os com pnpm pack:all, no monorepo do Prumo.`);
|
|
38
|
+
}
|
|
39
|
+
return tarballs;
|
|
40
|
+
}
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Os pacotes do Prumo que um app novo instala, na ordem em que o `pnpm pack:all` os empacota, e a
|
|
3
|
+
* versão de cada um. O `prumo new` grava `^<versão>` no `package.json` do app. A lista é conferida
|
|
4
|
+
* por um teste contra os `package.json` de `packages/*`: ao subir a versão de um pacote (o
|
|
5
|
+
* `pnpm changeset version`), o teste falha até este arquivo acompanhar.
|
|
6
|
+
*/
|
|
7
|
+
export declare const PRUMO_VERSIONS: Readonly<Record<string, string>>;
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Os pacotes do Prumo que um app novo instala, na ordem em que o `pnpm pack:all` os empacota, e a
|
|
3
|
+
* versão de cada um. O `prumo new` grava `^<versão>` no `package.json` do app. A lista é conferida
|
|
4
|
+
* por um teste contra os `package.json` de `packages/*`: ao subir a versão de um pacote (o
|
|
5
|
+
* `pnpm changeset version`), o teste falha até este arquivo acompanhar.
|
|
6
|
+
*/
|
|
7
|
+
export const PRUMO_VERSIONS = {
|
|
8
|
+
'@matizze/prumo-rules': '0.2.1',
|
|
9
|
+
'@matizze/prumo-core': '0.1.3',
|
|
10
|
+
'@matizze/prumo-testing': '0.2.1',
|
|
11
|
+
'@matizze/prumo-cli': '0.5.1',
|
|
12
|
+
'@matizze/prumo-mcp': '0.1.2',
|
|
13
|
+
};
|
package/dist/pnpm.d.ts
ADDED
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
import type { Runtime } from './runtime.js';
|
|
2
|
+
/** A versão, se for um semver simples; senão `undefined`. Nada que venha de fora passa sem isto. */
|
|
3
|
+
export declare function validPnpmVersion(text: string | undefined): string | undefined;
|
|
4
|
+
/**
|
|
5
|
+
* O pnpm que a pessoa usa, perguntando a ele (`pnpm --version`). Roda fora do projeto e sem baixar
|
|
6
|
+
* versões, porque nem o doctor nem o new usam a rede para isto. `undefined` se o pnpm não existe.
|
|
7
|
+
*/
|
|
8
|
+
export declare function pnpmVersion(): string | undefined;
|
|
9
|
+
/**
|
|
10
|
+
* A versão do pnpm que o `new` fixa em `packageManager`: a do `npm_config_user_agent` do runtime
|
|
11
|
+
* quando começa com `pnpm/<versão>` (o que o pnpm põe no ambiente em `dlx`, `exec` e `create`) e,
|
|
12
|
+
* senão, a que o próprio pnpm informa. Só vale um semver simples; sem versão válida, `undefined`.
|
|
13
|
+
*/
|
|
14
|
+
export declare function detectPnpmVersion(runtime: Runtime, ask?: () => string | undefined): string | undefined;
|
package/dist/pnpm.js
ADDED
|
@@ -0,0 +1,37 @@
|
|
|
1
|
+
import { spawnSync } from 'node:child_process';
|
|
2
|
+
import { tmpdir } from 'node:os';
|
|
3
|
+
/** Uma versão simples do pnpm: x.y.z, com pré-lançamento opcional (10.5.0, 11.0.0-rc.1). */
|
|
4
|
+
const SIMPLE_SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z]+(?:\.[0-9A-Za-z]+)*)?$/;
|
|
5
|
+
/** A versão, se for um semver simples; senão `undefined`. Nada que venha de fora passa sem isto. */
|
|
6
|
+
export function validPnpmVersion(text) {
|
|
7
|
+
const version = text?.trim();
|
|
8
|
+
return version && SIMPLE_SEMVER.test(version) ? version : undefined;
|
|
9
|
+
}
|
|
10
|
+
/**
|
|
11
|
+
* O pnpm que a pessoa usa, perguntando a ele (`pnpm --version`). Roda fora do projeto e sem baixar
|
|
12
|
+
* versões, porque nem o doctor nem o new usam a rede para isto. `undefined` se o pnpm não existe.
|
|
13
|
+
*/
|
|
14
|
+
export function pnpmVersion() {
|
|
15
|
+
const result = spawnSync('pnpm', ['--version'], {
|
|
16
|
+
cwd: tmpdir(),
|
|
17
|
+
encoding: 'utf8',
|
|
18
|
+
timeout: 20_000,
|
|
19
|
+
env: {
|
|
20
|
+
...process.env,
|
|
21
|
+
COREPACK_ENABLE_NETWORK: '0',
|
|
22
|
+
COREPACK_ENABLE_AUTO_PIN: '0',
|
|
23
|
+
npm_config_manage_package_manager_versions: 'false',
|
|
24
|
+
},
|
|
25
|
+
});
|
|
26
|
+
const version = result.stdout?.trim();
|
|
27
|
+
return result.status === 0 && version ? version : undefined;
|
|
28
|
+
}
|
|
29
|
+
/**
|
|
30
|
+
* A versão do pnpm que o `new` fixa em `packageManager`: a do `npm_config_user_agent` do runtime
|
|
31
|
+
* quando começa com `pnpm/<versão>` (o que o pnpm põe no ambiente em `dlx`, `exec` e `create`) e,
|
|
32
|
+
* senão, a que o próprio pnpm informa. Só vale um semver simples; sem versão válida, `undefined`.
|
|
33
|
+
*/
|
|
34
|
+
export function detectPnpmVersion(runtime, ask = pnpmVersion) {
|
|
35
|
+
const agent = /^pnpm\/(\S+)/.exec(runtime.env.npm_config_user_agent ?? '');
|
|
36
|
+
return validPnpmVersion(agent?.[1]) ?? validPnpmVersion(ask());
|
|
37
|
+
}
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
import { type SpawnSyncReturns } from 'node:child_process';
|
|
2
|
+
import type { Runtime } from './runtime.js';
|
|
3
|
+
/** O ambiente dos subprocessos: o do processo, com o do runtime por cima. */
|
|
4
|
+
export declare function childEnv(runtime: Runtime): NodeJS.ProcessEnv;
|
|
5
|
+
/** Onde e com que ambiente o subprocesso roda. */
|
|
6
|
+
export interface ChildOptions {
|
|
7
|
+
cwd: string;
|
|
8
|
+
/** O ambiente do filho. Padrão: o do processo, com o do runtime por cima (`childEnv`). */
|
|
9
|
+
env?: NodeJS.ProcessEnv;
|
|
10
|
+
}
|
|
11
|
+
/**
|
|
12
|
+
* Roda um subprocesso que escreve para quem usa o comando (o `pnpm install` do `new`): é o único
|
|
13
|
+
* lugar do cli que faz isso, e um teste proíbe `stdio: 'inherit'` e `process.stdout` fora daqui e
|
|
14
|
+
* do `bin.ts`.
|
|
15
|
+
*
|
|
16
|
+
* No terminal (`runtime.inheritStdio`), o filho herda os três fluxos e a pessoa vê o progresso. Fora
|
|
17
|
+
* dele, o stdin do filho é `ignore` (ele não lê o que o processo recebe, que num servidor MCP são os
|
|
18
|
+
* bytes do protocolo) e o stdout e o stderr são capturados e repassados, ao fim, a `runtime.out` e
|
|
19
|
+
* `runtime.err`. O resultado volta como o do `spawnSync`, com `stdout` e `stderr` em texto (vazios
|
|
20
|
+
* no terminal, onde o filho escreveu direto).
|
|
21
|
+
*/
|
|
22
|
+
export declare function runChild(runtime: Runtime, command: string, args: string[], options: ChildOptions): SpawnSyncReturns<string>;
|
package/dist/process.js
ADDED
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
import { spawnSync } from 'node:child_process';
|
|
2
|
+
/** O limite da saída capturada de um subprocesso: 64 MB, o que sobra de um `pnpm install` longo. */
|
|
3
|
+
const MAX_BUFFER = 64 * 1024 * 1024;
|
|
4
|
+
/** O ambiente dos subprocessos: o do processo, com o do runtime por cima. */
|
|
5
|
+
export function childEnv(runtime) {
|
|
6
|
+
return { ...process.env, ...runtime.env };
|
|
7
|
+
}
|
|
8
|
+
/**
|
|
9
|
+
* Roda um subprocesso que escreve para quem usa o comando (o `pnpm install` do `new`): é o único
|
|
10
|
+
* lugar do cli que faz isso, e um teste proíbe `stdio: 'inherit'` e `process.stdout` fora daqui e
|
|
11
|
+
* do `bin.ts`.
|
|
12
|
+
*
|
|
13
|
+
* No terminal (`runtime.inheritStdio`), o filho herda os três fluxos e a pessoa vê o progresso. Fora
|
|
14
|
+
* dele, o stdin do filho é `ignore` (ele não lê o que o processo recebe, que num servidor MCP são os
|
|
15
|
+
* bytes do protocolo) e o stdout e o stderr são capturados e repassados, ao fim, a `runtime.out` e
|
|
16
|
+
* `runtime.err`. O resultado volta como o do `spawnSync`, com `stdout` e `stderr` em texto (vazios
|
|
17
|
+
* no terminal, onde o filho escreveu direto).
|
|
18
|
+
*/
|
|
19
|
+
export function runChild(runtime, command, args, options) {
|
|
20
|
+
const env = options.env ?? childEnv(runtime);
|
|
21
|
+
if (runtime.inheritStdio) {
|
|
22
|
+
const result = spawnSync(command, args, {
|
|
23
|
+
cwd: options.cwd,
|
|
24
|
+
env,
|
|
25
|
+
encoding: 'utf8',
|
|
26
|
+
stdio: 'inherit',
|
|
27
|
+
});
|
|
28
|
+
return { ...result, stdout: '', stderr: '' };
|
|
29
|
+
}
|
|
30
|
+
const result = spawnSync(command, args, {
|
|
31
|
+
cwd: options.cwd,
|
|
32
|
+
env,
|
|
33
|
+
encoding: 'utf8',
|
|
34
|
+
stdio: ['ignore', 'pipe', 'pipe'],
|
|
35
|
+
maxBuffer: MAX_BUFFER,
|
|
36
|
+
});
|
|
37
|
+
// Mesmo com erro (estouro do buffer, filho morto por sinal), o que o filho já escreveu é repassado
|
|
38
|
+
const stdout = result.stdout ?? '';
|
|
39
|
+
const stderr = result.stderr ?? '';
|
|
40
|
+
if (stdout !== '')
|
|
41
|
+
runtime.out(stdout);
|
|
42
|
+
if (stderr !== '')
|
|
43
|
+
runtime.err(stderr);
|
|
44
|
+
return { ...result, stdout, stderr };
|
|
45
|
+
}
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
/** Os caminhos de um projeto Prumo que os comandos usam, todos absolutos. */
|
|
2
|
+
export interface Project {
|
|
3
|
+
/** A raiz: a pasta com `package.json` e `src`. */
|
|
4
|
+
root: string;
|
|
5
|
+
src: string;
|
|
6
|
+
/** `src/pages`: uma pasta por tela. */
|
|
7
|
+
pages: string;
|
|
8
|
+
/** `src/messages`: uma pasta por idioma, com um JSON por namespace e um `index.ts`. */
|
|
9
|
+
messages: string;
|
|
10
|
+
/** `src/App.tsx`: as rotas. */
|
|
11
|
+
app: string;
|
|
12
|
+
}
|
|
13
|
+
/**
|
|
14
|
+
* Acha o projeto em `root` e devolve os caminhos que os comandos usam. A raiz precisa existir, ser
|
|
15
|
+
* uma pasta e ter `package.json` e `src`: sem essa conferência, um comando apontado para a pasta
|
|
16
|
+
* errada não acharia nada e sairia como se estivesse tudo certo. Se a raiz não serve, lança um
|
|
17
|
+
* `UsageError` (saída 2) que explica o motivo.
|
|
18
|
+
*
|
|
19
|
+
* Só confere a raiz. Cada comando confere as pastas e os arquivos de que precisa, porque um
|
|
20
|
+
* projeto novo ainda não tem `src/pages` nem `App.tsx`.
|
|
21
|
+
*/
|
|
22
|
+
export declare function findProject(root: string): Project;
|
package/dist/project.js
ADDED
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
import { statSync } from 'node:fs';
|
|
2
|
+
import path from 'node:path';
|
|
3
|
+
import { UsageError } from "./errors.js";
|
|
4
|
+
/**
|
|
5
|
+
* Acha o projeto em `root` e devolve os caminhos que os comandos usam. A raiz precisa existir, ser
|
|
6
|
+
* uma pasta e ter `package.json` e `src`: sem essa conferência, um comando apontado para a pasta
|
|
7
|
+
* errada não acharia nada e sairia como se estivesse tudo certo. Se a raiz não serve, lança um
|
|
8
|
+
* `UsageError` (saída 2) que explica o motivo.
|
|
9
|
+
*
|
|
10
|
+
* Só confere a raiz. Cada comando confere as pastas e os arquivos de que precisa, porque um
|
|
11
|
+
* projeto novo ainda não tem `src/pages` nem `App.tsx`.
|
|
12
|
+
*/
|
|
13
|
+
export function findProject(root) {
|
|
14
|
+
const resolved = path.resolve(root);
|
|
15
|
+
const stat = statOf(resolved);
|
|
16
|
+
if (!stat)
|
|
17
|
+
throw new UsageError(`a pasta '${resolved}' não existe.`);
|
|
18
|
+
if (!stat.isDirectory())
|
|
19
|
+
throw new UsageError(`'${resolved}' não é uma pasta.`);
|
|
20
|
+
if (!statOf(path.join(resolved, 'package.json'))?.isFile()) {
|
|
21
|
+
throw new UsageError(`a pasta '${resolved}' não tem package.json: aponte --root para a raiz do projeto.`);
|
|
22
|
+
}
|
|
23
|
+
if (!statOf(path.join(resolved, 'src'))?.isDirectory()) {
|
|
24
|
+
throw new UsageError(`a pasta '${resolved}' não tem src: aponte --root para a raiz do projeto.`);
|
|
25
|
+
}
|
|
26
|
+
const src = path.join(resolved, 'src');
|
|
27
|
+
return {
|
|
28
|
+
root: resolved,
|
|
29
|
+
src,
|
|
30
|
+
pages: path.join(src, 'pages'),
|
|
31
|
+
messages: path.join(src, 'messages'),
|
|
32
|
+
app: path.join(src, 'App.tsx'),
|
|
33
|
+
};
|
|
34
|
+
}
|
|
35
|
+
function statOf(file) {
|
|
36
|
+
try {
|
|
37
|
+
return statSync(file);
|
|
38
|
+
}
|
|
39
|
+
catch {
|
|
40
|
+
return null;
|
|
41
|
+
}
|
|
42
|
+
}
|
package/dist/root.d.ts
ADDED
package/dist/root.js
ADDED
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
import { defineCommand } from 'citty';
|
|
2
|
+
import { createCheckCommand } from "./commands/check.js";
|
|
3
|
+
import { createDoctorCommand } from "./commands/doctor.js";
|
|
4
|
+
import { createMakeComponentCommand } from "./commands/make-component.js";
|
|
5
|
+
import { createMakeDomainCommand } from "./commands/make-domain.js";
|
|
6
|
+
import { createMakePageCommand } from "./commands/make-page.js";
|
|
7
|
+
import { createNewCommand } from "./commands/new.js";
|
|
8
|
+
/** A árvore de comandos do `prumo`. Cada comando novo entra em `subCommands`. */
|
|
9
|
+
export function createRoot(runtime) {
|
|
10
|
+
return defineCommand({
|
|
11
|
+
meta: {
|
|
12
|
+
name: 'prumo',
|
|
13
|
+
description: 'Prumo, a ferramenta da Matizze que cria e confere a arquitetura de apps React.',
|
|
14
|
+
},
|
|
15
|
+
subCommands: {
|
|
16
|
+
check: createCheckCommand(runtime),
|
|
17
|
+
doctor: createDoctorCommand(runtime),
|
|
18
|
+
'make:component': createMakeComponentCommand(runtime),
|
|
19
|
+
'make:domain': createMakeDomainCommand(runtime),
|
|
20
|
+
'make:page': createMakePageCommand(runtime),
|
|
21
|
+
new: createNewCommand(runtime),
|
|
22
|
+
},
|
|
23
|
+
});
|
|
24
|
+
}
|
package/dist/run.d.ts
ADDED
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
import { type AnyCommand } from './help.js';
|
|
2
|
+
import type { Runtime } from './runtime.js';
|
|
3
|
+
/**
|
|
4
|
+
* Roda a árvore de comandos e devolve o código de saída, sem encerrar o processo (o bin faz isso).
|
|
5
|
+
* O `runMain` do citty não serve de porta de entrada: ele sai com 1 em qualquer erro e escreve a
|
|
6
|
+
* ajuda e os erros em inglês, e o `prumo` precisa de 2 para uso errado. Por isso a rota é esta:
|
|
7
|
+
* acha o comando, mostra a ajuda se pediram, confere os argumentos e entrega ao `runCommand`.
|
|
8
|
+
*
|
|
9
|
+
* Códigos: 0 sem erro, o código do `ExitError` que o comando lançar (1 para o `check` com
|
|
10
|
+
* violação), 2 para uso errado (comando ou opção desconhecidos, argumento errado) e 1 para um erro
|
|
11
|
+
* inesperado.
|
|
12
|
+
*/
|
|
13
|
+
export declare function runCli(root: AnyCommand, rawArgs: string[], io: Pick<Runtime, 'out' | 'err'>): Promise<number>;
|
package/dist/run.js
ADDED
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
import { runCommand } from 'citty';
|
|
2
|
+
import { validateArgs } from "./args.js";
|
|
3
|
+
import { ExitError, UsageError } from "./errors.js";
|
|
4
|
+
import { renderHelp, resolveValue } from "./help.js";
|
|
5
|
+
const HELP_FLAGS = new Set(['--help', '-h']);
|
|
6
|
+
/**
|
|
7
|
+
* Acha o comando que os argumentos escolhem, descendo pelos subcomandos. Para no primeiro
|
|
8
|
+
* comando sem subcomandos, ou no grupo se ainda não há nome de comando nem pedido de ajuda.
|
|
9
|
+
*/
|
|
10
|
+
async function locate(root, rawArgs, name) {
|
|
11
|
+
let command = root;
|
|
12
|
+
let path = [name];
|
|
13
|
+
let rest = rawArgs;
|
|
14
|
+
for (;;) {
|
|
15
|
+
const subCommands = await resolveValue(command.subCommands ?? {});
|
|
16
|
+
if (Object.keys(subCommands).length === 0)
|
|
17
|
+
return { command, path, rest };
|
|
18
|
+
const [first, ...others] = rest;
|
|
19
|
+
if (first === undefined || HELP_FLAGS.has(first))
|
|
20
|
+
return { command, path, rest };
|
|
21
|
+
if (first.startsWith('-')) {
|
|
22
|
+
return { command, path, rest, problem: `opção desconhecida: '${first}'.` };
|
|
23
|
+
}
|
|
24
|
+
const next = subCommands[first];
|
|
25
|
+
if (!next)
|
|
26
|
+
return { command, path, rest, problem: `comando desconhecido: '${first}'.` };
|
|
27
|
+
command = await resolveValue(next);
|
|
28
|
+
path = [...path, first];
|
|
29
|
+
rest = others;
|
|
30
|
+
}
|
|
31
|
+
}
|
|
32
|
+
/**
|
|
33
|
+
* Roda a árvore de comandos e devolve o código de saída, sem encerrar o processo (o bin faz isso).
|
|
34
|
+
* O `runMain` do citty não serve de porta de entrada: ele sai com 1 em qualquer erro e escreve a
|
|
35
|
+
* ajuda e os erros em inglês, e o `prumo` precisa de 2 para uso errado. Por isso a rota é esta:
|
|
36
|
+
* acha o comando, mostra a ajuda se pediram, confere os argumentos e entrega ao `runCommand`.
|
|
37
|
+
*
|
|
38
|
+
* Códigos: 0 sem erro, o código do `ExitError` que o comando lançar (1 para o `check` com
|
|
39
|
+
* violação), 2 para uso errado (comando ou opção desconhecidos, argumento errado) e 1 para um erro
|
|
40
|
+
* inesperado.
|
|
41
|
+
*/
|
|
42
|
+
export async function runCli(root, rawArgs, io) {
|
|
43
|
+
const rootMeta = await resolveValue(root.meta ?? {});
|
|
44
|
+
const { command, path, rest, problem } = await locate(root, rawArgs, rootMeta.name ?? 'prumo');
|
|
45
|
+
const help = () => renderHelp(command, path);
|
|
46
|
+
const isGroup = Object.keys(await resolveValue(command.subCommands ?? {})).length > 0;
|
|
47
|
+
if (problem) {
|
|
48
|
+
io.err(`${path.join(' ')}: ${problem}\n\n${await help()}\n`);
|
|
49
|
+
return 2;
|
|
50
|
+
}
|
|
51
|
+
const upToDash = rest.slice(0, rest.indexOf('--') === -1 ? undefined : rest.indexOf('--'));
|
|
52
|
+
if (isGroup || upToDash.some((arg) => HELP_FLAGS.has(arg))) {
|
|
53
|
+
io.out(`${await help()}\n`);
|
|
54
|
+
return 0;
|
|
55
|
+
}
|
|
56
|
+
try {
|
|
57
|
+
validateArgs(await resolveValue(command.args ?? {}), rest);
|
|
58
|
+
await runCommand(root, { rawArgs });
|
|
59
|
+
return 0;
|
|
60
|
+
}
|
|
61
|
+
catch (error) {
|
|
62
|
+
if (error instanceof ExitError) {
|
|
63
|
+
if (error.message) {
|
|
64
|
+
const usage = error instanceof UsageError ? `\n${await help()}\n` : '';
|
|
65
|
+
io.err(`${path.join(' ')}: ${error.message}\n${usage}`);
|
|
66
|
+
}
|
|
67
|
+
return error.code;
|
|
68
|
+
}
|
|
69
|
+
io.err(`${path.join(' ')}: erro inesperado.\n${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
|
|
70
|
+
return 1;
|
|
71
|
+
}
|
|
72
|
+
}
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* O que os comandos usam do ambiente: onde escrever e a pasta de trabalho. O bin passa o terminal
|
|
3
|
+
* e o `process.cwd()`; os testes passam espaços em branco e uma pasta temporária, e assim rodam os
|
|
4
|
+
* comandos sem subprocesso.
|
|
5
|
+
*/
|
|
6
|
+
export interface Runtime {
|
|
7
|
+
out: (text: string) => void;
|
|
8
|
+
err: (text: string) => void;
|
|
9
|
+
cwd: string;
|
|
10
|
+
/** As variáveis de ambiente dos comandos. Os testes passam um mapa vazio. */
|
|
11
|
+
env: Readonly<Record<string, string | undefined>>;
|
|
12
|
+
/**
|
|
13
|
+
* O processo é o `prumo` do terminal: um subprocesso (o `pnpm install` do `new`) pode herdar o
|
|
14
|
+
* stdout, o stderr e o stdin e mostrar o progresso direto. Ausente ou falso, o stdout e o stderr
|
|
15
|
+
* do processo não são do comando (num servidor MCP, o stdout é o protocolo): a saída do filho é
|
|
16
|
+
* capturada e repassada a `out` e `err`, e o stdin dele é ignorado. Só o `bin.ts` o liga.
|
|
17
|
+
*/
|
|
18
|
+
inheritStdio?: boolean;
|
|
19
|
+
}
|
package/dist/runtime.js
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export {};
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
import type { Names } from './codemod/names.js';
|
|
2
|
+
/**
|
|
3
|
+
* A pasta dos modelos: `templates/`, na raiz do pacote. Fica um nível acima de `src/` e de `dist/`,
|
|
4
|
+
* então o mesmo caminho vale no workspace (que roda o código-fonte) e no pacote publicado (que
|
|
5
|
+
* roda o `dist/`, e leva a pasta pelo `files` do package.json).
|
|
6
|
+
*/
|
|
7
|
+
export declare const TEMPLATES_DIR: string;
|
|
8
|
+
/** Os valores dos marcadores de um modelo: `{ 'plural.kebab': 'clientes' }` para `{{plural.kebab}}`. */
|
|
9
|
+
export type TemplateVars = Readonly<Record<string, string>>;
|
|
10
|
+
/**
|
|
11
|
+
* Troca cada marcador `{{nome}}` do texto pelo valor de `nome`. O nome do marcador só tem letras,
|
|
12
|
+
* números e ponto, então um `{{` de JSX (`style={{ a: 1 }}`) não é marcador. Um marcador sem valor é
|
|
13
|
+
* erro do modelo e lança: gerar `undefined` no código de alguém seria pior que parar.
|
|
14
|
+
*/
|
|
15
|
+
export declare function renderTemplate(text: string, vars: TemplateVars): string;
|
|
16
|
+
/** O texto de um modelo, com o caminho relativo a `templates/` (`domain/schema.ts.tpl`). */
|
|
17
|
+
export declare function readTemplate(name: string): string;
|
|
18
|
+
/** Lê o modelo e troca os marcadores. */
|
|
19
|
+
export declare function renderTemplateFile(name: string, vars: TemplateVars): string;
|
|
20
|
+
/**
|
|
21
|
+
* Os marcadores de um nome: `<prefixo>.kebab` (`clientes`), `.pascal` (`Clientes`), `.camel`
|
|
22
|
+
* (`clientes`), `.constant` (`CLIENTES`, para constantes e códigos de erro; `pedidos-recentes`
|
|
23
|
+
* vira `PEDIDOS_RECENTES`) e `.title` (`Pedidos recentes`, o nome como texto para a pessoa ler:
|
|
24
|
+
* hífen vira espaço e a primeira letra sobe).
|
|
25
|
+
*/
|
|
26
|
+
export declare function nameVars(prefix: string, names: Names): Record<string, string>;
|