@effected/cli 0.25.0 → 0.27.0

package/CliTheme.js

@@ -1,142 +0,0 @@
-import { Glyphs } from "./Glyphs.js";
-import { openSequence, paintStyle } from "./internal/ansi.js";
-import { Token } from "./Token.js";
-import { Config, Context, Effect, Layer, Option } from "effect";
-import { TerminalEnv } from "@effected/env";
-import { Prompt } from "effect/cli";
-
-// src/CliTheme.ts
-/**
-* A stream theme at `color`, over a style resolution and a glyph set: the one way a {@link StreamTheme} is built.
-*
-* @internal
-*/
-const streamThemeAt = (resolve, glyphs, color) => {
-	const paint = (token, text) => paintStyle(resolve(token), color, text);
-	return {
-		paint,
-		style: resolve,
-		sgr: (token) => openSequence(resolve(token), color),
-		glyphs,
-		color,
-		status: (vocab, name, text) => {
-			const glyph = paint(vocab.def(name).token, vocab.glyph(name, glyphs));
-			return text === void 0 || text === "" ? glyph : `${glyph} ${text}`;
-		}
-	};
-};
-/** The audience rule, shared by `CliTheme.forAudience` and the class's own docs. */
-const forAudience = (theme, audience) => audience === "agent" && theme.color !== "none" ? streamThemeAt(theme.style, theme.glyphs, "none") : theme;
-const make = (colors, glyphs, overrides) => {
-	const resolve = (token) => Token.resolve(token, overrides);
-	const stdout = streamThemeAt(resolve, glyphs, colors.stdout);
-	const stderr = streamThemeAt(resolve, glyphs, colors.stderr);
-	return {
-		...stdout,
-		forStream: (stream) => stream === "stdout" ? stdout : stderr
-	};
-};
-/** The prompt glyphs that differ under ASCII; `Prompt.makeTheme` already holds the Unicode ones. */
-const ASCII_PROMPT_GLYPHS = {
-	prefix: "?",
-	arrowUp: "^",
-	arrowDown: "v",
-	checkboxOn: "[x]",
-	checkboxOff: "[ ]",
-	tick: "+",
-	pointerSmall: ">",
-	pointer: ">"
-};
-/**
-* The presentation of a CLI: colour tokens, glyphs and statuses, decided once from the terminal.
-*
-* @remarks
-* A `Context.Service`, not a `Reference`. A colour level is a fact about the terminal, not a preference with a
-* safe default, so there is nothing sensible for an unprovided theme to read; requiring it puts `CliTheme` in
-* `R` and a program that forgot to wire it fails to compile rather than printing plain text to a colour
-* terminal. {@link CliTheme.layer} reads `TerminalEnv`.
-*
-* @public
-*/
-var CliTheme = class CliTheme extends Context.Service()("@effected/cli/CliTheme") {
-	/**
-	* The theme for the terminal `TerminalEnv` describes.
-	*
-	* @remarks
-	* Bind the layer to a constant and provide it once. With `glyphs: "auto"` the glyph set is ASCII only when
-	* `TERM=dumb`, read through `Config`.
-	*
-	* @param options - token overrides and the glyph set
-	*/
-	static layer = (options) => Layer.effect(CliTheme, Effect.gen(function* () {
-		const terminal = yield* TerminalEnv;
-		const choice = options?.glyphs ?? "auto";
-		const term = choice === "auto" ? Option.getOrUndefined(yield* Config.option(Config.String("TERM")).pipe(Effect.orElseSucceed(() => Option.none()))) : void 0;
-		const glyphs = Glyphs.select({
-			ascii: choice === "ascii" ? true : choice === "unicode" ? false : "auto",
-			...term === void 0 ? {} : { term }
-		});
-		return make({
-			stdout: terminal.stdout.color,
-			stderr: terminal.stderr.color
-		}, glyphs, options?.tokens);
-	}));
-	/**
-	* The theme an audience sees of `theme`: for an agent, the same theme at colour `none` (`paint` the identity, `sgr`
-	* empty, `status` unpainted), whatever the terminal could do, because an agent never gets an escape of any kind; for
-	* anyone else, or when the audience is not known, `theme` itself.
-	*
-	* @remarks
-	* The one rule the kit applies wherever it paints for an audience: `Render.context` takes its colour and `paint`
-	* from it, `CliMessage` and `CliLog.status` paint their glyphs through it, and `./ui` gives it to the trees it
-	* mounts, so `useTheme`, `Styled` and the widgets' colour-`none` text markers all agree. A program that paints its
-	* own lines applies the same rule with it rather than re-implementing it:
-	*
-	* ```ts
-	* const line = Effect.gen(function* () {
-	*   const theme = CliTheme.forAudience((yield* CliTheme).forStream("stdout"), (yield* Audience).kind)
-	*   return theme.status(Status.core, "success", Fmt.sanitize(name))
-	* })
-	* ```
-	*
-	* Pure: it reads nothing, so the audience is the caller's to pass, `undefined` when it is not known.
-	*
-	* @param theme - a stream's theme, such as `CliTheme.forStream("stdout")`
-	* @param audience - who the output is for, or `undefined` when that is not known
-	*/
-	static forAudience = forAudience;
-	/**
-	* A fixed theme that needs nothing; `none` colour and Unicode glyphs unless told otherwise.
-	*
-	* @param options - the colour level and glyph set
-	*/
-	static layerTest = (options) => Layer.succeed(CliTheme, make({
-		stdout: options?.color ?? "none",
-		stderr: options?.stderrColor ?? options?.color ?? "none"
-	}, options?.glyphs === "ascii" ? Glyphs.ascii : Glyphs.unicode, void 0));
-	/**
-	* Sets core's `Prompt.Theme` from the tokens, so built-in prompts match the rest of the output.
-	*
-	* @remarks
-	* The colour fields are raw SGR openers and are empty strings when colour is `none`, and `colors` is the theme's
-	* own decision (`false` at `none`), so core's prompts and its command wizard write no colour or style escape, not
-	* even a reset, and core never re-reads the host for `NO_COLOR` or a TTY. Cursor and redraw controls are still
-	* written, whatever the theme says. Under ASCII glyphs the prompt symbols fall back to ASCII too.
-	*/
-	static promptTheme = Layer.effect(Prompt.Theme, Effect.gen(function* () {
-		const theme = yield* CliTheme;
-		const open = (token) => theme.sgr(token);
-		return Prompt.makeTheme({
-			...theme.glyphs.kind === "ascii" ? ASCII_PROMPT_GLYPHS : {},
-			ellipsis: theme.glyphs.ellipsis,
-			colors: theme.color !== "none",
-			primaryColor: open("accent"),
-			mutedColor: open("muted"),
-			successColor: open("success"),
-			errorColor: open("error"),
-			submittedColor: open("emphasis")
-		});
-	}));
-};
-
-export { CliTheme, streamThemeAt };

package/ConfigIssueRenderer.js

@@ -1,63 +0,0 @@
-import { formatIssueWithHints } from "./internal/format.js";
-
-// src/ConfigIssueRenderer.ts
-/**
-* Turns a `@effected/config-file` `ConfigValidationError` into one line per rejected value.
-*
-* @remarks
-* `ConfigValidationError` carries the structured `issue` tree rather than a
-* string, so a caller holds a tree it has to turn into sentences. This is that
-* step, the same treatment {@link SchemaIssueRenderer} gives a bare issue.
-*
-* `ConfigValidationError.message` names the file but not the value, and the
-* value is the diagnostic: printing only the message tells a user their config
-* is invalid without saying which value is wrong or how it is shaped.
-*
-* `@effected/config-file` is an optional peer, and this module only
-* `import type`s it, so the import is erased at build time. A consumer without
-* the package installed can import this module without the resolver being asked
-* for it.
-*
-* @example
-* ```ts
-* import { ConfigIssueRenderer } from "@effected/cli"
-* import { Effect } from "effect"
-*
-* const load = configFile.load.pipe(
-*   Effect.catchTag("ConfigValidationError", (error) =>
-*     Effect.gen(function* () {
-*       yield* Effect.logError(String(error))
-*       for (const line of ConfigIssueRenderer.render(error)) yield* Effect.logError(`  ${line}`)
-*     }),
-*   ),
-* )
-* ```
-*
-* @public
-*/
-var ConfigIssueRenderer = class {
-	constructor() {}
-	/**
-	* One line per rejected value.
-	*
-	* @remarks
-	* Takes the **error**, not its `issue`, because that is what a `catchTag`
-	* hands you and because `issue` is typed `Schema.Defect`, which every call
-	* site would otherwise have to reach into. Inside
-	* `Effect.catchTag("ConfigValidationError", …)` the error is already this
-	* type.
-	*
-	* An unknown key the schema has a near match for at the same path ends in a
-	* hint, `unknown key at theme.colour (did you mean "color"?)`, drawn from the
-	* keys the struct declares there (every branch's, under a union) with
-	* {@link Fmt.suggest}'s threshold. A key with no near match is drawn exactly
-	* as {@link SchemaIssueRenderer} draws it.
-	*
-	* It cannot throw on a malformed value: the issue tree is validated by
-	* a guard before it is read, so a renderer on an error path never becomes the
-	* reason a program dies.
-	*/
-	static render = (error) => formatIssueWithHints(error?.issue);
-};
-
-export { ConfigIssueRenderer };