@format.dev/cli 0.0.0 → 0.1.0

package/dist/lockstep.d.mts

@@ -0,0 +1,27 @@
+//#region src/versioning/deps.d.ts
+declare const DEPENDENCY_SECTIONS: readonly ["dependencies", "devDependencies", "optionalDependencies"];
+type DependencySection = (typeof DEPENDENCY_SECTIONS)[number];
+interface DependencyMismatch {
+  name: string;
+  section: DependencySection;
+  actual: string;
+  expected: string;
+}
+//#endregion
+//#region src/versioning/lockstep.d.ts
+interface LockstepStatus {
+  pinnedVersion: string | null;
+  mismatches: DependencyMismatch[];
+}
+/**
+ * The lockstep check behind `format version`, exposed as a library call so
+ * Studio and the compiler validate against the same source of truth —
+ * config.version — instead of each reimplementing it.
+ *
+ * Non-throwing: returns `pinnedVersion: null` when there's no resolvable config,
+ * so the caller decides whether that's fatal (Studio boot) or a skipped warning
+ * (a compile run outside a project).
+ */
+declare function getLockstepStatus(cwd: string): Promise<LockstepStatus>;
+//#endregion
+export { type DependencyMismatch, LockstepStatus, getLockstepStatus };

package/dist/lockstep.mjs

@@ -0,0 +1,30 @@
+import "./config-Dq7O4e8N.mjs";
+import { t as loadProjectState } from "./project-pX62Di_9.mjs";
+
+//#region src/versioning/lockstep.ts
+/**
+* The lockstep check behind `format version`, exposed as a library call so
+* Studio and the compiler validate against the same source of truth —
+* config.version — instead of each reimplementing it.
+*
+* Non-throwing: returns `pinnedVersion: null` when there's no resolvable config,
+* so the caller decides whether that's fatal (Studio boot) or a skipped warning
+* (a compile run outside a project).
+*/
+async function getLockstepStatus(cwd) {
+	try {
+		const state = await loadProjectState(cwd);
+		return {
+			pinnedVersion: state.pinnedVersion,
+			mismatches: state.mismatches
+		};
+	} catch {
+		return {
+			pinnedVersion: null,
+			mismatches: []
+		};
+	}
+}
+
+//#endregion
+export { getLockstepStatus };

package/dist/project-pX62Di_9.mjs

@@ -0,0 +1,124 @@
+import { a as readConfigFile, i as findConfigPath, r as detectIndent, s as CliError } from "./config-Dq7O4e8N.mjs";
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+//#region src/versioning/deps.ts
+const DEPENDENCY_SECTIONS = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies"
+];
+function packageJsonPathFor(configPath) {
+	const candidate = join(dirname(configPath), "package.json");
+	return existsSync(candidate) ? candidate : null;
+}
+async function scanFormatDependencies(packageJsonPath) {
+	const raw = await fs.readFile(packageJsonPath, "utf8");
+	const packageJson = JSON.parse(raw);
+	return DEPENDENCY_SECTIONS.flatMap((section) => {
+		const entries = packageJson[section] ?? {};
+		return Object.entries(entries).filter(([name]) => name.startsWith("@format.dev/")).map(([name, version]) => ({
+			name,
+			section,
+			version
+		}));
+	});
+}
+function findMismatches(args) {
+	const { pinnedVersion, dependencies } = args;
+	return dependencies.filter((dependency) => !dependency.version.startsWith("workspace:")).filter((dependency) => dependency.version !== pinnedVersion).map((dependency) => ({
+		name: dependency.name,
+		section: dependency.section,
+		actual: dependency.version,
+		expected: pinnedVersion
+	}));
+}
+async function rewriteFormatDependencies(args) {
+	const { packageJsonPath, version } = args;
+	const raw = await fs.readFile(packageJsonPath, "utf8");
+	const packageJson = JSON.parse(raw);
+	const rewritten = [];
+	for (const section of DEPENDENCY_SECTIONS) {
+		const entries = packageJson[section];
+		if (!entries) continue;
+		for (const [name, currentVersion] of Object.entries(entries)) {
+			const isNotFormatPackage = !name.startsWith("@format.dev/");
+			const isWorkspaceLink = currentVersion.startsWith("workspace:");
+			if (isNotFormatPackage || isWorkspaceLink || currentVersion === version) continue;
+			entries[name] = version;
+			rewritten.push({
+				name,
+				from: currentVersion,
+				to: version
+			});
+		}
+	}
+	if (rewritten.length > 0) {
+		const indent = detectIndent(raw);
+		await fs.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, indent)}\n`, "utf8");
+	}
+	return rewritten;
+}
+
+//#endregion
+//#region src/versioning/semver.ts
+const EXACT_SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+function isExactVersion(version) {
+	return EXACT_SEMVER.test(version);
+}
+function parseVersion(version) {
+	const match = /^(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z.-]+)?/.exec(version);
+	if (!match) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		hasPrerelease: match[4] !== void 0
+	};
+}
+function isNewer(candidate, current) {
+	const next = parseVersion(candidate);
+	const now = parseVersion(current);
+	if (!next || !now) return false;
+	if (next.major !== now.major) return next.major > now.major;
+	if (next.minor !== now.minor) return next.minor > now.minor;
+	if (next.patch !== now.patch) return next.patch > now.patch;
+	return now.hasPrerelease && !next.hasPrerelease;
+}
+function mayHaveBreakingChanges(from, to) {
+	const before = parseVersion(from);
+	const after = parseVersion(to);
+	if (!before || !after) return false;
+	if (after.major > before.major) return true;
+	return before.major === 0 && after.minor > before.minor;
+}
+
+//#endregion
+//#region src/project.ts
+const NO_CONFIG_MESSAGE = "Could not find a Format config file. It should be named format.config.{json|jsonc} and placed in the root of your repo. Run `npm create format` to start a new project.";
+async function loadProjectState(startDir) {
+	const configPath = findConfigPath(startDir, { baseName: process.env.FMT_CONFIG_FILE_NAME });
+	if (!configPath) throw new CliError(NO_CONFIG_MESSAGE);
+	const configFile = await readConfigFile(configPath);
+	const projectDir = dirname(configPath);
+	const rawVersion = configFile.config.version;
+	const pinnedVersion = typeof rawVersion === "string" ? rawVersion : null;
+	if (pinnedVersion && !isExactVersion(pinnedVersion)) throw new CliError(`Invalid "version" in ${configPath}: "${pinnedVersion}". It must be an exact version like "0.1.2" — ranges are not supported.`);
+	const packageJsonPath = packageJsonPathFor(configPath);
+	const dependencies = packageJsonPath ? await scanFormatDependencies(packageJsonPath) : [];
+	return {
+		configFile,
+		projectDir,
+		pinnedVersion,
+		packageJsonPath,
+		dependencies,
+		mismatches: pinnedVersion ? findMismatches({
+			pinnedVersion,
+			dependencies
+		}) : []
+	};
+}
+
+//#endregion
+export { rewriteFormatDependencies as a, mayHaveBreakingChanges as i, isExactVersion as n, isNewer as r, loadProjectState as t };

package/dist/random-name.d.mts

@@ -0,0 +1,2 @@
+import { t as drawRandomName } from "./draw-random-name-BzvSSVqO.mjs";
+export { drawRandomName };

package/dist/random-name.mjs

@@ -0,0 +1,3 @@
+import { t as drawRandomName } from "./draw-random-name-Dpt6YmUk.mjs";
+
+export { drawRandomName };

package/dist/scaffold-shared.d.mts

@@ -0,0 +1,2 @@
+import { C as methodsForFramework, S as isValidDimension, _ as SUPPORTED_FRAMEWORKS, a as DEFAULT_STYLING, b as isSchemaKind, c as PAGE_SIZES, d as SCHEMA_KINDS, f as SCHEMA_LABELS, g as STYLING_SUPPORT, h as STYLING_METHODS, i as DEFAULT_SCHEMA_KIND, l as PageSize, m as STYLING_LABELS, n as DEFAULT_PAGE_SIZE_ID, o as Framework, p as STYLING_DEPENDENCIES, r as DEFAULT_PAGE_WIDTH, s as MAX_PAGE_DIMENSION, t as DEFAULT_PAGE_HEIGHT, u as SCHEMA_DEPENDENCIES, v as SchemaKind, x as isStylingMethod, y as StylingMethod } from "./shared-BD62UD5L.mjs";
+export { DEFAULT_PAGE_HEIGHT, DEFAULT_PAGE_SIZE_ID, DEFAULT_PAGE_WIDTH, DEFAULT_SCHEMA_KIND, DEFAULT_STYLING, Framework, MAX_PAGE_DIMENSION, PAGE_SIZES, PageSize, SCHEMA_DEPENDENCIES, SCHEMA_KINDS, SCHEMA_LABELS, STYLING_DEPENDENCIES, STYLING_LABELS, STYLING_METHODS, STYLING_SUPPORT, SUPPORTED_FRAMEWORKS, SchemaKind, StylingMethod, isSchemaKind, isStylingMethod, isValidDimension, methodsForFramework };

package/dist/scaffold-shared.mjs

@@ -0,0 +1,3 @@
+import { _ as isStylingMethod, a as DEFAULT_STYLING, c as SCHEMA_DEPENDENCIES, d as STYLING_DEPENDENCIES, f as STYLING_LABELS, g as isSchemaKind, h as SUPPORTED_FRAMEWORKS, i as DEFAULT_SCHEMA_KIND, l as SCHEMA_KINDS, m as STYLING_SUPPORT, n as DEFAULT_PAGE_SIZE_ID, o as MAX_PAGE_DIMENSION, p as STYLING_METHODS, r as DEFAULT_PAGE_WIDTH, s as PAGE_SIZES, t as DEFAULT_PAGE_HEIGHT, u as SCHEMA_LABELS, v as isValidDimension, y as methodsForFramework } from "./shared-CM3vyUlL.mjs";
+
+export { DEFAULT_PAGE_HEIGHT, DEFAULT_PAGE_SIZE_ID, DEFAULT_PAGE_WIDTH, DEFAULT_SCHEMA_KIND, DEFAULT_STYLING, MAX_PAGE_DIMENSION, PAGE_SIZES, SCHEMA_DEPENDENCIES, SCHEMA_KINDS, SCHEMA_LABELS, STYLING_DEPENDENCIES, STYLING_LABELS, STYLING_METHODS, STYLING_SUPPORT, SUPPORTED_FRAMEWORKS, isSchemaKind, isStylingMethod, isValidDimension, methodsForFramework };

package/dist/scaffold.d.mts

@@ -0,0 +1,191 @@
+import { t as drawRandomName } from "./draw-random-name-BzvSSVqO.mjs";
+import { C as methodsForFramework, o as Framework, v as SchemaKind, y as StylingMethod } from "./shared-BD62UD5L.mjs";
+
+//#region src/scaffold/document/types.d.ts
+interface ScaffoldProjectConfig {
+  framework: Framework;
+  rootDir?: string;
+}
+type TemplateId = 'blank';
+declare const DEFAULT_TEMPLATE: TemplateId;
+declare const EMPTY_STYLESHEET_COMMENT = "/* Your styles go here */\n";
+interface GeneratedFile {
+  path: string;
+  contents: string;
+}
+interface MissingDependency {
+  name: string;
+  dev: boolean;
+}
+interface MissingConfig {
+  description: string;
+  example?: string;
+}
+interface PrerequisiteReport {
+  method: StylingMethod;
+  satisfied: boolean;
+  missingDependencies: MissingDependency[];
+  missingConfig: MissingConfig[];
+  steps: string[];
+}
+interface CreateDocumentArgs {
+  config: ScaffoldProjectConfig;
+  projectRoot: string;
+  name: string;
+  styling?: StylingMethod;
+  template?: TemplateId;
+  emitSchema?: boolean;
+  schemaKind?: SchemaKind;
+  width?: number;
+  height?: number;
+  data?: unknown;
+  empty?: boolean;
+}
+interface CreateDocumentResult {
+  documentName: string;
+  documentDir: string;
+  filesWritten: string[];
+  prerequisites: PrerequisiteReport;
+}
+interface StyleApplication {
+  imports: string[];
+  declarations: string[];
+  wrapperTag?: string;
+  headingTag: string;
+  headingClass?: string;
+  headingClassExpr?: string;
+  hintTag: string;
+  hintClass?: string;
+  hintClassExpr?: string;
+  vueStyleBlock?: string;
+}
+interface ApplyStyleArgs {
+  framework: Framework;
+  documentName: string;
+  exportName: string;
+}
+interface StylingStrategy {
+  method: StylingMethod;
+  frameworks: Framework[];
+  files(args: ApplyStyleArgs): GeneratedFile[];
+  emptyFiles?(args: ApplyStyleArgs): GeneratedFile[];
+  apply(args: ApplyStyleArgs): StyleApplication;
+  checkPrerequisites(args: CheckPrerequisitesArgs): Promise<PrerequisiteReport>;
+  setupProject?(args: SetupProjectArgs): Promise<ProjectSetupResult>;
+}
+interface CheckPrerequisitesArgs {
+  config: ScaffoldProjectConfig;
+  projectRoot: string;
+}
+interface SetupProjectArgs {
+  config: ScaffoldProjectConfig;
+  projectRoot: string;
+  formatConfigPath: string;
+  documentsGlobBase: string;
+}
+interface ProjectSetupResult {
+  method: StylingMethod;
+  ok: boolean;
+  summary: string[];
+}
+//#endregion
+//#region src/scaffold/document/create-document.d.ts
+declare const DOCUMENTS_DIR_NAME = "documents";
+interface GetDocumentsDirArgs {
+  projectRoot: string;
+  config: ScaffoldProjectConfig;
+}
+declare function getDocumentsDir(args: GetDocumentsDirArgs): string;
+declare function readExistingDocumentNames(documentsDir: string): Promise<string[]>;
+interface DocumentPlan {
+  documentName: string;
+  documentDir: string;
+  files: GeneratedFile[];
+  prerequisites: PrerequisiteReport;
+  projectRoot: string;
+}
+declare function buildDocumentPlan(args: CreateDocumentArgs): Promise<DocumentPlan>;
+declare function writeDocument(plan: DocumentPlan): Promise<void>;
+declare function createDocument(args: CreateDocumentArgs): Promise<CreateDocumentResult>;
+//#endregion
+//#region src/scaffold/document/install.d.ts
+interface InstallSummary {
+  requested: boolean;
+  attempted: boolean;
+  ok: boolean;
+  packages: string[];
+  packageManager?: string;
+  message?: string;
+  output?: string;
+}
+interface MaybeInstallArgs {
+  wanted: boolean;
+  projectRoot: string;
+  emitSchema: boolean;
+  schemaKind?: SchemaKind;
+  missingStylingDependencies: string[];
+  onInstallStart?: (packages: string[]) => void;
+  onProgress?: (line: string) => void;
+}
+declare function maybeInstallDependencies(args: MaybeInstallArgs): Promise<InstallSummary>;
+interface MaybeSetupProjectArgs {
+  wanted: boolean;
+  styling: string | undefined;
+  config: ScaffoldProjectConfig;
+  projectRoot: string;
+  formatConfigPath: string;
+  documentsGlobBase: string;
+}
+declare function maybeSetupProject(args: MaybeSetupProjectArgs): Promise<ProjectSetupResult | null>;
+//#endregion
+//#region src/scaffold/document/validate-name.d.ts
+declare const RESERVED_DOCUMENT_NAMES: string[];
+interface ValidateDocumentNameArgs {
+  name: string;
+  existingNames: string[];
+}
+type ValidateDocumentNameResult = {
+  ok: true;
+} | {
+  ok: false;
+  reason: string;
+  suggestion?: string;
+};
+declare function validateDocumentName(args: ValidateDocumentNameArgs): ValidateDocumentNameResult;
+interface SuggestAvailableNameArgs {
+  name: string;
+  existingNames: string[];
+}
+declare function suggestAvailableName(args: SuggestAvailableNameArgs): string;
+//#endregion
+//#region src/scaffold/document/random-name.d.ts
+interface GenerateRandomNameArgs {
+  existingNames: string[];
+  maxAttempts?: number;
+}
+declare function generateRandomName(args: GenerateRandomNameArgs): string;
+//#endregion
+//#region src/scaffold/document/styling/strategies.d.ts
+declare const STYLING_STRATEGIES: StylingStrategy[];
+//#endregion
+//#region src/scaffold/document/styling/index.d.ts
+interface ResolveStylingArgs {
+  framework: Framework;
+  method: StylingMethod;
+}
+declare function resolveStyling(args: ResolveStylingArgs): StylingStrategy;
+//#endregion
+//#region src/scaffold/document/styling/prerequisites.d.ts
+declare function readProjectDependencies(projectRoot: string): Promise<Set<string>>;
+//#endregion
+//#region src/scaffold/document/document-names.d.ts
+declare const RESERVED_WORDS: Set<string>;
+declare function getDocumentExportName(documentName: string): string;
+declare function buildDocumentExportMap(documentNames: string[]): Map<string, string>;
+//#endregion
+//#region src/errors.d.ts
+declare class CliError extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { type ApplyStyleArgs, type CheckPrerequisitesArgs, CliError, type CreateDocumentArgs, type CreateDocumentResult, DEFAULT_TEMPLATE, DOCUMENTS_DIR_NAME, type DocumentPlan, EMPTY_STYLESHEET_COMMENT, type GeneratedFile, type InstallSummary, type MaybeInstallArgs, type MaybeSetupProjectArgs, type MissingConfig, type MissingDependency, type PrerequisiteReport, type ProjectSetupResult, RESERVED_DOCUMENT_NAMES, RESERVED_WORDS, STYLING_STRATEGIES, type ScaffoldProjectConfig, type SetupProjectArgs, type StyleApplication, type StylingMethod, type StylingStrategy, type TemplateId, type ValidateDocumentNameResult, buildDocumentExportMap, buildDocumentPlan, createDocument, drawRandomName, generateRandomName, getDocumentExportName, getDocumentsDir, maybeInstallDependencies, maybeSetupProject, methodsForFramework, readExistingDocumentNames, readProjectDependencies, resolveStyling, suggestAvailableName, validateDocumentName, writeDocument };

package/dist/scaffold.mjs

@@ -0,0 +1,6 @@
+import { s as CliError } from "./config-Dq7O4e8N.mjs";
+import { _ as RESERVED_WORDS, a as DOCUMENTS_DIR_NAME, b as DEFAULT_TEMPLATE, c as getDocumentsDir, d as resolveStyling, f as STYLING_STRATEGIES, g as validateDocumentName, h as suggestAvailableName, i as generateRandomName, l as readExistingDocumentNames, m as RESERVED_DOCUMENT_NAMES, n as maybeSetupProject, o as buildDocumentPlan, p as readProjectDependencies, s as createDocument, t as maybeInstallDependencies, u as writeDocument, v as buildDocumentExportMap, x as EMPTY_STYLESHEET_COMMENT, y as getDocumentExportName } from "./install-BiDrmMgJ.mjs";
+import { y as methodsForFramework } from "./shared-CM3vyUlL.mjs";
+import { t as drawRandomName } from "./draw-random-name-Dpt6YmUk.mjs";
+
+export { CliError, DEFAULT_TEMPLATE, DOCUMENTS_DIR_NAME, EMPTY_STYLESHEET_COMMENT, RESERVED_DOCUMENT_NAMES, RESERVED_WORDS, STYLING_STRATEGIES, buildDocumentExportMap, buildDocumentPlan, createDocument, drawRandomName, generateRandomName, getDocumentExportName, getDocumentsDir, maybeInstallDependencies, maybeSetupProject, methodsForFramework, readExistingDocumentNames, readProjectDependencies, resolveStyling, suggestAvailableName, validateDocumentName, writeDocument };

package/dist/shared-BD62UD5L.d.mts

@@ -0,0 +1,32 @@
+//#region src/scaffold/shared.d.ts
+type Framework = 'react' | 'vue' | 'html';
+declare const SUPPORTED_FRAMEWORKS: readonly Framework[];
+type StylingMethod = 'css' | 'css-modules' | 'vue-sfc-scoped' | 'scss' | 'tailwind' | 'linaria' | 'vanilla-extract' | 'panda-css';
+declare const DEFAULT_STYLING: StylingMethod;
+declare const STYLING_METHODS: StylingMethod[];
+declare const STYLING_SUPPORT: Record<StylingMethod, Framework[]>;
+declare const STYLING_DEPENDENCIES: Record<StylingMethod, string[]>;
+declare const STYLING_LABELS: Record<StylingMethod, string>;
+declare function methodsForFramework(framework: Framework): StylingMethod[];
+declare function isStylingMethod(value: string): value is StylingMethod;
+type SchemaKind = 'zod' | 'valibot' | 'joi' | 'yup';
+declare const DEFAULT_SCHEMA_KIND: SchemaKind;
+declare const SCHEMA_KINDS: SchemaKind[];
+declare const SCHEMA_LABELS: Record<SchemaKind, string>;
+declare const SCHEMA_DEPENDENCIES: Record<SchemaKind, string>;
+declare function isSchemaKind(value: string): value is SchemaKind;
+interface PageSize {
+  id: string;
+  name: string;
+  label: string;
+  width: number;
+  height: number;
+}
+declare const PAGE_SIZES: PageSize[];
+declare const DEFAULT_PAGE_SIZE_ID = "a4";
+declare const DEFAULT_PAGE_WIDTH: number;
+declare const DEFAULT_PAGE_HEIGHT: number;
+declare const MAX_PAGE_DIMENSION = 20000;
+declare function isValidDimension(value: number): boolean;
+//#endregion
+export { methodsForFramework as C, isValidDimension as S, SUPPORTED_FRAMEWORKS as _, DEFAULT_STYLING as a, isSchemaKind as b, PAGE_SIZES as c, SCHEMA_KINDS as d, SCHEMA_LABELS as f, STYLING_SUPPORT as g, STYLING_METHODS as h, DEFAULT_SCHEMA_KIND as i, PageSize as l, STYLING_LABELS as m, DEFAULT_PAGE_SIZE_ID as n, Framework as o, STYLING_DEPENDENCIES as p, DEFAULT_PAGE_WIDTH as r, MAX_PAGE_DIMENSION as s, DEFAULT_PAGE_HEIGHT as t, SCHEMA_DEPENDENCIES as u, SchemaKind as v, isStylingMethod as x, StylingMethod as y };

package/dist/shared-CM3vyUlL.mjs

@@ -0,0 +1,143 @@
+//#region src/scaffold/shared.ts
+const SUPPORTED_FRAMEWORKS = [
+	"react",
+	"vue",
+	"html"
+];
+const DEFAULT_STYLING = "css";
+const STYLING_METHODS = [
+	"css",
+	"css-modules",
+	"vue-sfc-scoped",
+	"scss",
+	"tailwind",
+	"linaria",
+	"vanilla-extract",
+	"panda-css"
+];
+const STYLING_SUPPORT = {
+	css: [
+		"react",
+		"vue",
+		"html"
+	],
+	"css-modules": ["react", "vue"],
+	"vue-sfc-scoped": ["vue"],
+	scss: [
+		"react",
+		"vue",
+		"html"
+	],
+	tailwind: [
+		"react",
+		"vue",
+		"html"
+	],
+	linaria: ["react"],
+	"vanilla-extract": ["react"],
+	"panda-css": ["react", "vue"]
+};
+const STYLING_DEPENDENCIES = {
+	css: [],
+	"css-modules": [],
+	"vue-sfc-scoped": [],
+	scss: [],
+	tailwind: ["tailwindcss"],
+	linaria: ["@linaria/react", "@linaria/core"],
+	"vanilla-extract": ["@vanilla-extract/css"],
+	"panda-css": ["@pandacss/dev"]
+};
+const STYLING_LABELS = {
+	css: "Plain CSS",
+	"css-modules": "CSS Modules",
+	"vue-sfc-scoped": "Scoped (Vue SFC)",
+	scss: "SCSS",
+	tailwind: "Tailwind",
+	linaria: "Linaria",
+	"vanilla-extract": "Vanilla Extract",
+	"panda-css": "Panda CSS"
+};
+function methodsForFramework(framework) {
+	return STYLING_METHODS.filter((method) => STYLING_SUPPORT[method].includes(framework));
+}
+function isStylingMethod(value) {
+	return STYLING_METHODS.includes(value);
+}
+const DEFAULT_SCHEMA_KIND = "zod";
+const SCHEMA_KINDS = [
+	"zod",
+	"valibot",
+	"joi",
+	"yup"
+];
+const SCHEMA_LABELS = {
+	zod: "Zod",
+	valibot: "Valibot",
+	joi: "Joi",
+	yup: "Yup"
+};
+const SCHEMA_DEPENDENCIES = {
+	zod: "zod",
+	valibot: "valibot",
+	joi: "joi",
+	yup: "yup"
+};
+function isSchemaKind(value) {
+	return SCHEMA_KINDS.includes(value);
+}
+const PAGE_SIZES = [
+	{
+		id: "a3",
+		name: "A3",
+		label: "297 × 420 mm",
+		width: 1122.52,
+		height: 1587.4
+	},
+	{
+		id: "a4",
+		name: "A4",
+		label: "210 × 297 mm",
+		width: 793.71,
+		height: 1122.52
+	},
+	{
+		id: "a5",
+		name: "A5",
+		label: "148 × 210 mm",
+		width: 559.37,
+		height: 793.71
+	},
+	{
+		id: "letter",
+		name: "US Letter",
+		label: "8.5 × 11 in",
+		width: 816,
+		height: 1056
+	},
+	{
+		id: "slide-16-9",
+		name: "Slide 16:9",
+		label: "1280 × 720 px",
+		width: 1280,
+		height: 720
+	},
+	{
+		id: "slide-4-3",
+		name: "Slide 4:3",
+		label: "1024 × 768 px",
+		width: 1024,
+		height: 768
+	}
+];
+const DEFAULT_PAGE_SIZE_ID = "a4";
+const defaultPageSize = PAGE_SIZES.find((size) => size.id === DEFAULT_PAGE_SIZE_ID);
+if (!defaultPageSize) throw new Error(`DEFAULT_PAGE_SIZE_ID "${DEFAULT_PAGE_SIZE_ID}" has no matching entry in PAGE_SIZES.`);
+const DEFAULT_PAGE_WIDTH = defaultPageSize.width;
+const DEFAULT_PAGE_HEIGHT = defaultPageSize.height;
+const MAX_PAGE_DIMENSION = 2e4;
+function isValidDimension(value) {
+	return Number.isFinite(value) && value > 0 && value <= MAX_PAGE_DIMENSION;
+}
+
+//#endregion
+export { isStylingMethod as _, DEFAULT_STYLING as a, SCHEMA_DEPENDENCIES as c, STYLING_DEPENDENCIES as d, STYLING_LABELS as f, isSchemaKind as g, SUPPORTED_FRAMEWORKS as h, DEFAULT_SCHEMA_KIND as i, SCHEMA_KINDS as l, STYLING_SUPPORT as m, DEFAULT_PAGE_SIZE_ID as n, MAX_PAGE_DIMENSION as o, STYLING_METHODS as p, DEFAULT_PAGE_WIDTH as r, PAGE_SIZES as s, DEFAULT_PAGE_HEIGHT as t, SCHEMA_LABELS as u, isValidDimension as v, methodsForFramework as y };

package/env.d.ts

@@ -0,0 +1,99 @@
+declare module '@format:*' {
+	const mod: any
+	export default mod
+}
+
+declare module '*.html' {
+	const html: string
+	export default html
+}
+
+declare module '*.module.css' {
+	const classes: { readonly [className: string]: string }
+	export default classes
+}
+
+declare module '*.module.scss' {
+	const classes: { readonly [className: string]: string }
+	export default classes
+}
+
+declare module '*.module.sass' {
+	const classes: { readonly [className: string]: string }
+	export default classes
+}
+
+declare module '*.css' {}
+
+declare module '*.scss' {}
+
+declare module '*.sass' {}
+
+declare module '*.svg' {
+	import type * as React from 'react'
+
+	const ReactComponent: React.FunctionComponent<React.SVGProps<SVGSVGElement> & { title?: string }>
+
+	export default ReactComponent
+	export { ReactComponent }
+}
+
+declare module '*.svg?raw' {
+	const content: string
+	export default content
+}
+
+declare module '*.png' {
+	const src: string
+	export default src
+}
+
+declare module '*.jpg' {
+	const src: string
+	export default src
+}
+
+declare module '*.jpeg' {
+	const src: string
+	export default src
+}
+
+declare module '*.gif' {
+	const src: string
+	export default src
+}
+
+declare module '*.webp' {
+	const src: string
+	export default src
+}
+
+declare module '*.avif' {
+	const src: string
+	export default src
+}
+
+declare module '*.woff' {
+	const src: string
+	export default src
+}
+
+declare module '*.woff2' {
+	const src: string
+	export default src
+}
+
+declare module '*.ttf' {
+	const src: string
+	export default src
+}
+
+declare module '*.otf' {
+	const src: string
+	export default src
+}
+
+declare module '*.eot' {
+	const src: string
+	export default src
+}