@digdir/designsystemet 0.0.0-deps-tsdown-20260421103939

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2024 Digitaliseringsdirektoratet (Digdir)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+# @digdir/designsystemet
+
+CLI and tooling for Designsystemet
+
+Use `--help` for available commands and options
+
+Read the Designsystemet [README](https://github.com/digdir/designsystemet) to get started.
+
+
+## Usage
+
+### Create tokens
+
+Use `npx @digdir/designsystemet tokens create <options>` to create design tokens for use with Designsystemet.
+
+This allows you to define themes including custom colors, font-family, and border-radius.
+We recommend using the [Designsystemet theme builder](https://theme.designsystemet.no/) for generating a valid command with correct options.
+
+#### Update tokens
+
+Whenever a new version of the CLI is released, or you have done changes, we recommend to update design tokens with the `--clean` option to potentially remove any changes deprecated files or unneeded files.
+
+To update design tokens, re-run `npx @digdir/designsystemet tokens create <options> --clean`. 
+If a [config file](#using-a-config-file) you can also re-run with `"clean": true`.
+
+> ⚠️ **WARNING** ⚠️  
+> The design tokens created by this tool are considered an implementation detail, and is subject
+> to change at any time without being considered a breaking change. We **only** support customisations
+> done through the CLI options and config. Direct editing of the design tokens are **not** supported.
+> 
+> Since tokens may be added or removed at any time, it is necessary to routinely re-run this
+> command when upgrading the libraries. This will remove any direct edits to the design tokens.
+
+### Build CSS from tokens
+
+Use `npx @digdir/designsystemet tokens build <options>` to build CSS from design tokens generated in the previous step.
+
+> ⚠️ **WARNING** ⚠️  
+> The CSS files from created by this tool are considered build artifacts. They should **not** be
+> edited directly. While the CSS will not change unexpectedly, new variables may be added at any
+> time. Therefore, it is necessary to routinely re-run this command when upgrading the libraries.
+> This will remove any direct edits to the CSS.
+
+#### Update built CSS
+
+Whenever a new version of the CLI is released, or you have done changes, we recommend to build a new set of CSS from design tokens with the `--clean` option to potentially remove any changes deprecated files or unneeded files.
+
+
+### Using a config file
+
+> ⚠️ **WARNING** ⚠️  
+> The typography feature is experimental. The config schema may change at any time.
+
+
+The `tokens create` command supports a config file. It will auto-detect a `designsystemet.config.json` file in the current directory. You can also use the `--config <path>` option to supply a different config name and location.
+
+The main advantage of using a config file is for automation in scenarios with multiple themes.
+
+To get started, use this template for a `designsystemet.config.json` file:
+
+```jsonc
+{
+  "$schema": "node_modules/@digdir/designsystemet/dist/config.schema.json",
+}
+```
+
+In editors which support JSON Schema, the `$schema` will then  give you editor hints for the structure of the file.
+
+#### Minimal config example
+As a minimal example, the following CLI snippet from the theme builder
+
+```
+npx @digdir/designsystemet tokens create \
+--main-colors "primary:#0062BA" "accent:#1E98F5" \
+--neutral-color "#1E2B3C" \
+--support-colors "extra1:#F45F63" "extra2:#E5AA20" \
+--border-radius 4 \
+--theme "theme"
+```
+
+...is equivalent to this `designsystemet.config.json` file
+```jsonc
+{
+  "$schema": "./node_modules/@digdir/designsystemet/dist/config.schema.json",
+  "outDir": "../path/to/design-tokens",
+  "themes": {
+    "theme": {
+      "colors": {
+        "main": { "primary": "#0062BA", "accent": "#1E98F5" },
+        "neutral": "#1E2B3C",
+        "support": { "extra1": "#F45F63", "extra2": "#E5AA20" }
+      },
+      "borderRadius": 4
+    }
+  }
+}
+```
+To generate new design tokens and CSS files, you would then run.
+
+```
+npx @digdir/designsystemet tokens create
+npx @digdir/designsystemet tokens build
+```
+
+#### Complex config example
+
+Have a look at the `*.config.json` files under the `packages/cli` in the Github repo for more complex examples.
+
+#### Create config from existing tokens
+
+You can get a minimal config file, meaning without overrides, generated from existing design tokens using the following command:
+
+```sh
+npx @digdir/designsystemet generate-config-from-tokens --dir <path to design tokens>
+```

package/configs/test-tokens.config.json

@@ -0,0 +1,82 @@
+{
+  "$schema": "../dist/config.schema.json",
+  "outDir": "./temp/config/design-tokens",
+  "clean": true,
+  "themes": {
+    "some-org": {
+      "colors": {
+        "main": {
+          "dominant": "#0062BA",
+          "complimentary": "#94237C"
+        },
+        "support": {
+          "first": "#F45F63",
+          "second": "#E5AA20",
+          "third": "#1E98F5",
+          "fourth": "#F167EC"
+        },
+        "neutral": "#303030"
+      },
+      "typography": {
+        "fontFamily": "Inter"
+      },
+      "borderRadius": 8,
+      "overrides": {
+        "colors": {
+          "dominant": {
+            "background-default": {
+              "light": "#ff0000",
+              "dark": "#000fff"
+            },
+            "background-tinted": {
+              "light": "#f0ff00",
+              "dark": "#ff00ff"
+            }
+          },
+          "danger": {
+            "background-default": {
+              "light": "#0000ff",
+              "dark": "#0000ff"
+            }
+          }
+        },
+        "severity": {
+          "danger": "#ff00ff"
+        },
+        "linkVisited": {
+          "light": "#ff1234",
+          "dark": "#1234ff"
+        },
+        "focus": {
+          "inner": {
+            "light": "#00ff00",
+            "dark": "#00ffff"
+          },
+          "outer": {
+            "light": "#ffff00",
+            "dark": "#ff00aa"
+          }
+        }
+      }
+    },
+    "other-org": {
+      "colors": {
+        "main": {
+          "dominant": "#ffaaaa",
+          "complimentary": "#00ff00"
+        },
+        "support": {
+          "first": "#abcdef",
+          "second": "#123456",
+          "third": "#994a22",
+          "fourth": "#3d5f30"
+        },
+        "neutral": "#c05030"
+      },
+      "typography": {
+        "fontFamily": "Roboto"
+      },
+      "borderRadius": 99
+    }
+  }
+}

package/dist/bin/config.d.ts

@@ -0,0 +1,12 @@
+import type { Command, OptionValues } from '@commander-js/extra-typings';
+import { type BuildConfigSchema, type CreateConfigSchema } from '../src/config.js';
+export declare function readConfigFile(configFilePath: string, allowFileNotFound?: boolean): Promise<string>;
+export declare function parseCreateConfig(configFile: string, options: {
+    theme: string;
+    cmd: Command<unknown[], OptionValues>;
+    configFilePath: string;
+}): Promise<CreateConfigSchema>;
+export declare function parseBuildConfig(configFile: string, { configFilePath }: {
+    configFilePath: string;
+}): Promise<BuildConfigSchema>;
+//# sourceMappingURL=config.d.ts.map

package/dist/bin/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../bin/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGzE,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EAKxB,MAAM,kBAAkB,CAAC;AAI1B,wBAAsB,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE,iBAAiB,UAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAkBtG;AAED,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,EAAE,YAAY,CAAC,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACxF,OAAO,CAAC,kBAAkB,CAAC,CAiE7B;AAED,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,EAClB,EAAE,cAAc,EAAE,EAAE;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,iBAAiB,CAAC,CAI5B"}

package/dist/bin/config.js

@@ -0,0 +1,58 @@
+import { commonConfig, configFileCreateSchema, parseConfig, validateConfig } from "../src/config.js";
+import { dsfs } from "../src/utils/filesystem.js";
+import { getCliOption, getDefaultCliOption, getSuppliedCliOption } from "./options.js";
+import pc from "picocolors";
+import * as R from "ramda";
+//#region bin/config.ts
+async function readConfigFile(configFilePath, allowFileNotFound = true) {
+	let configFile;
+	try {
+		configFile = await dsfs.readFile(configFilePath, allowFileNotFound);
+	} catch (err) {
+		if (allowFileNotFound) return "";
+		console.error(pc.redBright(`Could not read config file at ${pc.blue(configFilePath)}`));
+		throw err;
+	}
+	if (configFile) console.log(`Found config file: ${pc.green(configFilePath)}`);
+	return configFile;
+}
+async function parseCreateConfig(configFile, options) {
+	const { cmd, theme = "theme", configFilePath } = options;
+	const configParsed = parseConfig(configFile, configFilePath);
+	const themeColors = Object.values(configParsed?.themes ?? {}).map((x) => new Set([...R.keys(x.colors.main), ...R.keys(x.colors.support)]));
+	if (!R.all(R.equals(R.__, themeColors[0]), themeColors)) {
+		console.error(pc.redBright(`In config, all themes must have the same custom color names, but we found:`));
+		const themeNames = R.keys(configParsed.themes ?? {});
+		themeColors.forEach((colors, index) => {
+			const colorNames = Array.from(colors);
+			console.log(`  - ${themeNames[index]}: ${colorNames.join(", ")}`);
+		});
+		console.log();
+		process.exit(1);
+	}
+	const noUndefined = R.reject(R.isNil);
+	const getThemeOptions = (optionGetter) => noUndefined({
+		colors: noUndefined({
+			main: optionGetter(cmd, "mainColors"),
+			support: optionGetter(cmd, "supportColors"),
+			neutral: optionGetter(cmd, "neutralColor")
+		}),
+		typography: noUndefined({ fontFamily: optionGetter(cmd, "fontFamily") }),
+		borderRadius: optionGetter(cmd, "borderRadius"),
+		defaultColor: optionGetter(cmd, "defaultColor")
+	});
+	return validateConfig(configFileCreateSchema, noUndefined({
+		outDir: configParsed?.outDir ?? getCliOption(cmd, "outDir"),
+		clean: configParsed?.clean ?? getCliOption(cmd, "clean"),
+		themes: configParsed?.themes ? R.map((jsonThemeValues) => {
+			const defaultThemeValues = getThemeOptions(getDefaultCliOption);
+			const cliThemeValues = getThemeOptions(getSuppliedCliOption);
+			return R.mergeDeepRight(defaultThemeValues, R.mergeDeepRight(jsonThemeValues, cliThemeValues));
+		}, configParsed.themes) : { [theme]: getThemeOptions(getCliOption) }
+	}), configFilePath);
+}
+async function parseBuildConfig(configFile, { configFilePath }) {
+	return validateConfig(commonConfig, parseConfig(configFile, configFilePath), configFilePath);
+}
+//#endregion
+export { parseBuildConfig, parseCreateConfig, readConfigFile };

package/dist/bin/designsystemet.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare const figletAscii = "\n _____            _                           _                      _\n|  __ \\          (_)                         | |                    | |\n| |  | | ___  ___ _  __ _ _ __  ___ _   _ ___| |_ ___ _ __ ___   ___| |_\n| |  | |/ _ \\/ __| |/ _` | '_ \\/ __| | | / __| __/ _ \\ '_ ` _ \\ / _ \\ __|\n| |__| |  __/\\__ \\ | (_| | | | \\__ \\ |_| \\__ \\ ||  __/ | | | | |  __/ |_\n|_____/ \\___||___/_|\\__, |_| |_|___/\\__, |___/\\__\\___|_| |_| |_|\\___|\\__|\n                     __/ |           __/ |\n                    |___/           |___/\n";
+//# sourceMappingURL=designsystemet.d.ts.map

package/dist/bin/designsystemet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"designsystemet.d.ts","sourceRoot":"","sources":["../../bin/designsystemet.ts"],"names":[],"mappings":";AAgBA,eAAO,MAAM,WAAW,4iBASvB,CAAC"}

package/dist/bin/designsystemet.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import { convertToHex } from "../src/colors/utils.js";
+import "../src/colors/index.js";
+import { cliOptions, createTokens } from "../src/tokens/create.js";
+import { dsfs } from "../src/utils/filesystem.js";
+import { parseCreateConfig, readConfigFile } from "./config.js";
+import migrations_default from "../src/migrations/index.js";
+import { buildTokens } from "../src/tokens/build.js";
+import { createTokenFiles } from "../src/tokens/create/files.js";
+import { generateConfigFromTokens } from "../src/tokens/generate-config.js";
+import pc from "picocolors";
+import * as R from "ramda";
+import path from "node:path";
+import { Argument, createCommand, program } from "@commander-js/extra-typings";
+//#region bin/designsystemet.ts
+const figletAscii = `
+ _____            _                           _                      _
+|  __ \\          (_)                         | |                    | |
+| |  | | ___  ___ _  __ _ _ __  ___ _   _ ___| |_ ___ _ __ ___   ___| |_
+| |  | |/ _ \\/ __| |/ _\` | '_ \\/ __| | | / __| __/ _ \\ '_ \` _ \\ / _ \\ __|
+| |__| |  __/\\__ \\ | (_| | | | \\__ \\ |_| \\__ \\ ||  __/ | | | | |  __/ |_
+|_____/ \\___||___/_|\\__, |_| |_|___/\\__, |___/\\__\\___|_| |_| |_|\\___|\\__|
+                     __/ |           __/ |
+                    |___/           |___/
+`;
+program.name("designsystemet").description("CLI for working with Designsystemet").showHelpAfterError();
+const DEFAULT_TOKENS_CREATE_DIR = "./design-tokens";
+const DEFAULT_TOKENS_BUILD_DIR = "./design-tokens-build";
+const DEFAULT_FONT = "Inter";
+const DEFAULT_THEME_NAME = "theme";
+const DEFAULT_CONFIG_FILEPATH = "designsystemet.config.json";
+function makeTokenCommands() {
+	const tokenCmd = createCommand("tokens");
+	tokenCmd.command("build").description("Build Designsystemet tokens").option("-t, --tokens <string>", `Path to ${pc.blue("design-tokens")}`, DEFAULT_TOKENS_CREATE_DIR).option("-o, --out-dir <string>", `Output directory for built ${pc.blue("design-tokens")}`, DEFAULT_TOKENS_BUILD_DIR).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before building tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for built ${pc.blue("design-tokens")}`, parseBoolean, false).option("--verbose", "Enable verbose output", false).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILEPATH}")`).option("--experimental-tailwind", "Generate Tailwind CSS classes for tokens", false).action(async (opts) => {
+		console.log(figletAscii);
+		const { verbose, clean, dry, experimentalTailwind, tokens } = opts;
+		dsfs.init({
+			dry,
+			outdir: opts.outDir,
+			verbose
+		});
+		const outDir = dsfs.outDir;
+		if (clean) await dsfs.cleanDir(outDir);
+		const files = await buildTokens({
+			tokensDir: tokens,
+			verbose,
+			tailwind: experimentalTailwind
+		});
+		console.log(`\n💾 Writing build to ${pc.green(outDir)}`);
+		await dsfs.writeFiles(files, outDir, true);
+		console.log(`\n✅ Finished building tokens in ${pc.green(outDir)}`);
+		return Promise.resolve();
+	});
+	tokenCmd.command("create").description("Create Designsystemet tokens").option(`-m, --${cliOptions.theme.colors.main} <name:hex...>`, `Main colors`, parseColorValues).option(`-s, --${cliOptions.theme.colors.support} <name:hex...>`, `Support colors`, parseColorValues).option(`-n, --${cliOptions.theme.colors.neutral} <hex>`, `Neutral hex color`, convertToHex).option(`-o, --${cliOptions.outDir} <string>`, `Output directory for created ${pc.blue("design-tokens")}`, DEFAULT_TOKENS_CREATE_DIR).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before creating tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for created ${pc.blue("design-tokens")}`, parseBoolean, false).option(`-f, --${cliOptions.theme.typography.fontFamily} <string>`, `Font family (experimental)`, DEFAULT_FONT).option(`-b, --${cliOptions.theme.borderRadius} <number>`, `Unitless base border-radius in px`, (radiusAsString) => Number(radiusAsString), 4).option("--theme <string>", "Theme name (ignored when using JSON config file)", DEFAULT_THEME_NAME).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILEPATH}")`).action(async (opts, cmd) => {
+		console.log(figletAscii);
+		if (opts.dry) console.log(`Performing dry run, no files will be written`);
+		const themeName = opts.theme;
+		const { configFile, configFilePath } = await getConfigFile(opts.config);
+		const config = await parseCreateConfig(configFile, {
+			theme: themeName,
+			cmd,
+			configFilePath
+		});
+		const themeNames = Object.keys(config.themes);
+		if (themeNames.length > 0) console.log(`Using themes from config file: ${pc.blue(themeNames.join(", "))}`);
+		dsfs.init({
+			dry: opts.dry,
+			outdir: config.outDir
+		});
+		const outDir = dsfs.outDir;
+		if (config.clean) await dsfs.cleanDir(outDir);
+		let files = [];
+		if (config.themes) for (const [name, themeWithoutName] of Object.entries(config.themes)) {
+			const theme = {
+				name,
+				...themeWithoutName
+			};
+			const { tokenSets } = await createTokens(theme);
+			files = files.concat(await createTokenFiles({
+				outDir,
+				theme,
+				tokenSets,
+				themeNames
+			}));
+		}
+		await dsfs.writeFiles(files, outDir);
+		console.log(`\n✅ Finished creating tokens in ${pc.green(outDir)} for themes: ${pc.blue(themeNames.join(", "))}`);
+		return Promise.resolve();
+	});
+	return tokenCmd;
+}
+program.addCommand(makeTokenCommands());
+program.command("generate-config-from-tokens").description("Generate a config file from existing design tokens. Will not include overrides.").option("-d, --dir <string>", "Path to design tokens directory", DEFAULT_TOKENS_CREATE_DIR).option("-o, --out <string>", "Output path for config file", DEFAULT_CONFIG_FILEPATH).option("--dry [boolean]", "Dry run - show config without writing file", parseBoolean, false).action(async (opts) => {
+	console.log(figletAscii);
+	const { dry } = opts;
+	const tokensDir = path.resolve(opts.dir);
+	const configFilePath = path.resolve(opts.out);
+	dsfs.init({
+		dry,
+		outdir: path.dirname(configFilePath)
+	});
+	try {
+		const config = await generateConfigFromTokens({
+			tokensDir,
+			outFile: configFilePath
+		});
+		if (dry) {
+			console.log();
+			console.log("Generated config (dry run):");
+			console.log(JSON.stringify(config, null, 2));
+		}
+		if (configFilePath) {
+			const configJson = JSON.stringify(config, null, 2);
+			await dsfs.writeFile(configFilePath, configJson);
+			console.log();
+			console.log(`\n✅ Config file written to ${pc.blue(configFilePath)}`);
+		}
+	} catch (error) {
+		console.error(pc.redBright("Error generating config:"));
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+});
+program.command("migrate").description("run a Designsystemet migration").addArgument(new Argument("[migration]", "Available migrations").choices(Object.keys(migrations_default))).option("-l --list", "List available migrations").option("-g --glob <glob>", "Glob for files upon which to apply the migration", "./**/*.(tsx|css)").action((migrationKey, opts) => {
+	console.log(figletAscii);
+	const { glob, list } = opts;
+	if (list) for (const key of Object.keys(migrations_default)) console.log(key);
+	else if (migrationKey) {
+		const migration = migrations_default[migrationKey];
+		if (!migration) {
+			console.error("Migration not found!");
+			throw "Aborting";
+		}
+		console.log(`Applying migration ${pc.blue(migrationKey)} with glob: ${pc.green(glob)}`);
+		migration?.(glob).then(() => console.log(`Migration ${pc.blue(migrationKey)} finished`)).catch((error) => console.log(error));
+	} else console.log("Migrate: please specify a migration name or --list");
+});
+await program.parseAsync(process.argv);
+function parseColorValues(value, previous = {}) {
+	const [name, hex] = value.split(":");
+	previous[name] = convertToHex(hex);
+	return previous;
+}
+function parseBoolean(value) {
+	return value === "true" || value === true;
+}
+async function getConfigFile(userConfigFilePath) {
+	const allowFileNotFound = R.isNil(userConfigFilePath) || userConfigFilePath === DEFAULT_CONFIG_FILEPATH;
+	const configFilePath = userConfigFilePath ?? DEFAULT_CONFIG_FILEPATH;
+	return {
+		configFile: await readConfigFile(configFilePath, allowFileNotFound),
+		configFilePath
+	};
+}
+//#endregion
+export { figletAscii };

package/dist/bin/options.d.ts

@@ -0,0 +1,21 @@
+import type { Command, OptionValueSource, OptionValues } from '@commander-js/extra-typings';
+declare const getOptionIfMatchingSource: (...sources: OptionValueSource[]) => <Args extends unknown[], Opts extends OptionValues, K extends keyof Opts>(command: Command<Args, Opts>, option: K) => Opts[K] | undefined;
+export type OptionGetter = ReturnType<typeof getOptionIfMatchingSource>;
+/**
+ * Get an option value if it is explicitly supplied to the CLI command.
+ * The difference between this and using the option directly is that we return undefined
+ * instead of the default value if the option was not explicitly set.
+ */
+export declare const getSuppliedCliOption: <Args extends unknown[], Opts extends OptionValues, K extends keyof Opts>(command: Command<Args, Opts>, option: K) => Opts[K] | undefined;
+/**
+ * Get the default value specified for a CLI command option.
+ * Mostly useful for getting values which may later be overridden.
+ */
+export declare const getDefaultCliOption: <Args extends unknown[], Opts extends OptionValues, K extends keyof Opts>(command: Command<Args, Opts>, option: K) => Opts[K] | undefined;
+/**
+ * Try to get the explicitly supplied CLI option, and fall back to the default value
+ * for the option as defined in the {@link Command}
+ */
+export declare const getCliOption: <Args extends unknown[], Opts extends OptionValues, K extends keyof Opts>(command: Command<Args, Opts>, option: K) => Opts[K] | undefined;
+export {};
+//# sourceMappingURL=options.d.ts.map

package/dist/bin/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../bin/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE5F,QAAA,MAAM,yBAAyB,GAC5B,GAAG,SAAS,iBAAiB,EAAE,MAC/B,IAAI,SAAS,OAAO,EAAE,EAAE,IAAI,SAAS,YAAY,EAAE,CAAC,SAAS,MAAM,IAAI,EACtE,SAAS,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,EAC5B,QAAQ,CAAC,wBAMV,CAAC;AAEJ,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAExE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAjB9B,IAAI,SAAS,OAAO,EAAE,EAAE,IAAI,SAAS,YAAY,EAAE,CAAC,SAAS,MAAM,IAAI,WAC7D,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,UACpB,CAAC,wBAeuD,CAAC;AAErE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAvB7B,IAAI,SAAS,OAAO,EAAE,EAAE,IAAI,SAAS,YAAY,EAAE,CAAC,SAAS,MAAM,IAAI,WAC7D,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,UACpB,CAAC,wBAqB0D,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,YAAY,GA7BtB,IAAI,SAAS,OAAO,EAAE,EAAE,IAAI,SAAS,YAAY,EAAE,CAAC,SAAS,MAAM,IAAI,WAC7D,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,UACpB,CAAC,wBA2B0D,CAAC"}

package/dist/bin/options.js

@@ -0,0 +1,23 @@
+//#region bin/options.ts
+const getOptionIfMatchingSource = (...sources) => (command, option) => {
+	const source = command.getOptionValueSource(option);
+	if (sources.includes(source)) return command.getOptionValue(option);
+};
+/**
+* Get an option value if it is explicitly supplied to the CLI command.
+* The difference between this and using the option directly is that we return undefined
+* instead of the default value if the option was not explicitly set.
+*/
+const getSuppliedCliOption = getOptionIfMatchingSource("cli");
+/**
+* Get the default value specified for a CLI command option.
+* Mostly useful for getting values which may later be overridden.
+*/
+const getDefaultCliOption = getOptionIfMatchingSource("default");
+/**
+* Try to get the explicitly supplied CLI option, and fall back to the default value
+* for the option as defined in the {@link Command}
+*/
+const getCliOption = getOptionIfMatchingSource("cli", "default");
+//#endregion
+export { getCliOption, getDefaultCliOption, getSuppliedCliOption };