@f-o-t/config 0.1.0

package/README.md

@@ -0,0 +1,179 @@
+# @f-o-t/config
+
+Standardized configuration for F-O-T libraries. Provides a type-safe configuration system with validation, plugins, and config file generators.
+
+## Installation
+
+```bash
+bun add @f-o-t/config
+```
+
+## Usage
+
+### Basic Usage
+
+The simplest way to use `@f-o-t/config` is to call `defineFotConfig()` with no arguments to get default configuration:
+
+```typescript
+import { defineFotConfig } from "@f-o-t/config";
+
+const config = defineFotConfig();
+// Returns default config with ESM format, TypeScript declarations, and Biome enabled
+```
+
+### With Custom Options
+
+Customize the configuration by passing options:
+
+```typescript
+import { defineFotConfig } from "@f-o-t/config";
+
+const config = defineFotConfig({
+  formats: ["esm", "cjs"],
+  external: ["react", "react-dom"],
+  typescript: {
+    declaration: true,
+  },
+  biome: {
+    enabled: true,
+  },
+});
+```
+
+### With Plugins
+
+Enable and configure plugins:
+
+```typescript
+import { defineFotConfig } from "@f-o-t/config";
+
+const config = defineFotConfig({
+  plugins: [
+    { name: "datetime", enabled: true },
+    { name: "pdf", enabled: false },
+  ],
+});
+```
+
+## Generate Config Files
+
+The library provides generators to create standard configuration files for your FOT library:
+
+```typescript
+import { 
+  generatePackageJson, 
+  generateTsConfig, 
+  generateBiomeConfig 
+} from "@f-o-t/config";
+
+// Generate package.json
+const packageJson = generatePackageJson({
+  name: "@f-o-t/my-library",
+  version: "1.0.0",
+  description: "My FOT library",
+});
+
+// Generate tsconfig.json
+const tsconfig = generateTsConfig();
+
+// Generate biome.json
+const biomeConfig = generateBiomeConfig();
+```
+
+## API Reference
+
+### `defineFotConfig(config?: FotConfig): ResolvedFotConfig`
+
+Main factory function to define and validate a FOT library configuration.
+
+**Parameters:**
+- `config` (optional): Configuration object
+
+**Returns:** Validated configuration with all defaults applied
+
+**Throws:** Error if configuration is invalid
+
+### Types
+
+#### `FotConfig`
+
+User-provided configuration:
+
+```typescript
+interface FotConfig {
+  formats?: BuildFormat[];        // Build output formats (default: ["esm"])
+  external?: string[];            // External dependencies (default: [])
+  typescript?: TypeScriptOptions; // TypeScript options
+  biome?: BiomeOptions;          // Biome options
+  plugins?: PluginConfig[];      // Plugin configurations (default: [])
+}
+```
+
+#### `ResolvedFotConfig`
+
+Fully resolved configuration with all defaults applied:
+
+```typescript
+interface ResolvedFotConfig {
+  formats: BuildFormat[];
+  external: string[];
+  typescript: Required<TypeScriptOptions>;
+  biome: Required<BiomeOptions>;
+  plugins: PluginConfig[];
+}
+```
+
+#### `BuildFormat`
+
+```typescript
+type BuildFormat = "esm" | "cjs";
+```
+
+#### `TypeScriptOptions`
+
+```typescript
+interface TypeScriptOptions {
+  declaration?: boolean;  // Generate .d.ts files (default: true)
+}
+```
+
+#### `BiomeOptions`
+
+```typescript
+interface BiomeOptions {
+  enabled?: boolean;  // Enable Biome (default: true)
+}
+```
+
+#### `PluginConfig`
+
+```typescript
+interface PluginConfig {
+  name: string;      // Plugin name
+  enabled?: boolean; // Enable plugin (default: true)
+}
+```
+
+## Generators
+
+### `generatePackageJson(options)`
+
+Generates a standard package.json configuration for FOT libraries.
+
+**Parameters:**
+- `name`: Package name
+- `version`: Package version
+- `description`: Package description
+- Additional package.json fields as needed
+
+### `generateTsConfig()`
+
+Generates a standard TypeScript configuration optimized for FOT libraries.
+
+### `generateBiomeConfig()`
+
+Generates a standard Biome configuration for linting and formatting.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,283 @@
+/**
+* Build output formats
+*/
+type BuildFormat = "esm" | "cjs";
+/**
+* TypeScript compiler options for the build
+*/
+interface TypeScriptOptions {
+	/**
+	* Generate .d.ts declaration files
+	* @default true
+	*/
+	declaration?: boolean;
+}
+/**
+* Biome configuration options
+*/
+interface BiomeOptions {
+	/**
+	* Enable Biome for linting/formatting
+	* @default true
+	*/
+	enabled?: boolean;
+}
+/**
+* Plugin configuration
+*/
+interface PluginConfig {
+	/**
+	* Name of the plugin
+	*/
+	name: string;
+	/**
+	* Whether the plugin is enabled
+	* @default true
+	*/
+	enabled?: boolean;
+}
+/**
+* User-provided configuration for FOT libraries
+*/
+interface FotConfig {
+	/**
+	* Build output formats
+	* @default ["esm"]
+	*/
+	formats?: BuildFormat[];
+	/**
+	* External dependencies that should not be bundled
+	* @default []
+	*/
+	external?: string[];
+	/**
+	* TypeScript options
+	*/
+	typescript?: TypeScriptOptions;
+	/**
+	* Biome options
+	*/
+	biome?: BiomeOptions;
+	/**
+	* Plugins to load - can be plugin names as strings or config objects
+	* @default []
+	*/
+	plugins?: (string | PluginConfig)[];
+}
+/**
+* Resolved configuration with all defaults applied
+*/
+interface ResolvedFotConfig {
+	/**
+	* Build output formats
+	*/
+	formats: BuildFormat[];
+	/**
+	* External dependencies that should not be bundled
+	*/
+	external: string[];
+	/**
+	* TypeScript options
+	*/
+	typescript: Required<TypeScriptOptions>;
+	/**
+	* Biome options
+	*/
+	biome: Required<BiomeOptions>;
+	/**
+	* Plugins to load (normalized to config objects)
+	*/
+	plugins: PluginConfig[];
+}
+/**
+* Factory function to define a FOT library configuration
+* Validates the config against the schema and applies defaults
+*
+* @param config - The library configuration
+* @returns The validated and normalized configuration with defaults applied
+* @throws {Error} If the configuration is invalid
+*/
+declare function defineFotConfig(config?: FotConfig): ResolvedFotConfig;
+/**
+* Biome configuration structure
+*/
+interface BiomeConfig {
+	$schema: string;
+	vcs: {
+		enabled: boolean;
+		clientKind: string;
+		useIgnoreFile: boolean;
+		defaultBranch: string;
+	};
+	files: {
+		ignoreUnknown: boolean;
+		ignore: string[];
+	};
+	formatter: {
+		enabled: boolean;
+		indentStyle: string;
+		indentWidth: number;
+		lineWidth: number;
+	};
+	organizeImports: {
+		enabled: boolean;
+	};
+	linter: {
+		enabled: boolean;
+		rules: {
+			recommended: boolean;
+		};
+	};
+	javascript: {
+		formatter: {
+			quoteStyle: string;
+			semicolons: string;
+			trailingCommas: string;
+		};
+	};
+}
+/**
+* Generate a biome.json file from a resolved FOT configuration
+*
+* @param config - The resolved FOT configuration
+* @returns The generated biome.json object
+*/
+declare function generateBiomeConfig(config: ResolvedFotConfig): BiomeConfig;
+/**
+* Package.json configuration
+*/
+interface PackageExport {
+	types: string;
+	default: string;
+}
+/**
+* Package.json structure
+*/
+interface PackageJson {
+	name: string;
+	version: string;
+	type: "module";
+	main: string;
+	types: string;
+	exports: Record<string, PackageExport>;
+	scripts: Record<string, string>;
+	dependencies?: Record<string, string>;
+	devDependencies: Record<string, string>;
+	repository: {
+		type: "git";
+		url: string;
+		directory: string;
+	};
+}
+/**
+* Generate a package.json file from a resolved FOT configuration
+*
+* @param libraryName - The name of the library (without @f-o-t/ prefix)
+* @param version - The version of the library
+* @param config - The resolved FOT configuration
+* @param customDependencies - Optional custom dependencies to include
+* @returns The generated package.json object
+*/
+declare function generatePackageJson(libraryName: string, version: string, config: ResolvedFotConfig, customDependencies?: Record<string, string>): PackageJson;
+/**
+* TypeScript configuration structure
+*/
+interface TSConfig {
+	compilerOptions: {
+		allowImportingTsExtensions: boolean;
+		declaration: boolean;
+		isolatedDeclarations: boolean;
+		module: string;
+		moduleDetection: string;
+		moduleResolution: string;
+		noEmit: boolean;
+		noFallthroughCasesInSwitch: boolean;
+		noImplicitOverride: boolean;
+		noPropertyAccessFromIndexSignature: boolean;
+		noUncheckedIndexedAccess: boolean;
+		noUnusedLocals: boolean;
+		noUnusedParameters: boolean;
+		skipLibCheck: boolean;
+		strict: boolean;
+		target: string;
+		verbatimModuleSyntax: boolean;
+	};
+	exclude: string[];
+	include: string[];
+}
+/**
+* Generate a tsconfig.json file from a resolved FOT configuration
+*
+* @param config - The resolved FOT configuration
+* @returns The generated tsconfig.json object
+*/
+declare function generateTSConfig(config: ResolvedFotConfig): TSConfig;
+import { z } from "zod";
+/**
+* Schema for build output formats
+*/
+declare const buildFormatSchema: z.ZodEnum<{
+	esm: "esm";
+	cjs: "cjs";
+}>;
+/**
+* Schema for plugin configuration
+* Accepts either a string (plugin name) or a config object
+*/
+declare const pluginConfigSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+	name: z.ZodString;
+	enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>]>, z.ZodTransform<{
+	name: string;
+	enabled: boolean;
+}, string | {
+	name: string;
+	enabled: boolean;
+}>>;
+/**
+* Schema for TypeScript compiler options
+*/
+declare const typeScriptOptionsSchema: z.ZodDefault<z.ZodObject<{
+	declaration: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+/**
+* Schema for Biome configuration options
+*/
+declare const biomeOptionsSchema: z.ZodDefault<z.ZodObject<{
+	enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+/**
+* Schema for FOT configuration
+*/
+declare const fotConfigSchema: z.ZodObject<{
+	formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+		esm: "esm";
+		cjs: "cjs";
+	}>>>;
+	external: z.ZodDefault<z.ZodArray<z.ZodString>>;
+	typescript: z.ZodDefault<z.ZodObject<{
+		declaration: z.ZodDefault<z.ZodBoolean>;
+	}, z.core.$strip>>;
+	biome: z.ZodDefault<z.ZodObject<{
+		enabled: z.ZodDefault<z.ZodBoolean>;
+	}, z.core.$strip>>;
+	plugins: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+		name: z.ZodString;
+		enabled: z.ZodDefault<z.ZodBoolean>;
+	}, z.core.$strip>]>, z.ZodTransform<{
+		name: string;
+		enabled: boolean;
+	}, string | {
+		name: string;
+		enabled: boolean;
+	}>>>>;
+}, z.core.$strip>;
+/**
+* Type for input configuration (before validation and defaults)
+*/
+type FotConfigInput = z.input<typeof fotConfigSchema>;
+/**
+* Type for output configuration (after validation and defaults)
+*/
+type FotConfigOutput = z.output<typeof fotConfigSchema>;
+export { typeScriptOptionsSchema, pluginConfigSchema, generateTSConfig, generatePackageJson, generateBiomeConfig, fotConfigSchema, defineFotConfig, buildFormatSchema, biomeOptionsSchema, TypeScriptOptions, TSConfig, ResolvedFotConfig, PluginConfig, PackageJson, PackageExport, FotConfigOutput, FotConfigInput, FotConfig, BuildFormat, BiomeOptions, BiomeConfig };

package/dist/index.js

@@ -0,0 +1,160 @@
+// src/schemas.ts
+import { z } from "zod";
+var packageNameRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+var buildFormatSchema = z.enum(["esm", "cjs"]);
+var pluginConfigSchema = z.union([
+  z.string(),
+  z.object({
+    name: z.string(),
+    enabled: z.boolean().default(true)
+  })
+]).transform((val) => {
+  if (typeof val === "string") {
+    return { name: val, enabled: true };
+  }
+  return { name: val.name, enabled: val.enabled ?? true };
+});
+var typeScriptOptionsSchema = z.object({
+  declaration: z.boolean().default(true)
+}).default({ declaration: true });
+var biomeOptionsSchema = z.object({
+  enabled: z.boolean().default(true)
+}).default({ enabled: true });
+var fotConfigSchema = z.object({
+  formats: z.array(buildFormatSchema).default(["esm"]),
+  external: z.array(z.string().regex(packageNameRegex, {
+    message: "Invalid package name format"
+  })).default([]),
+  typescript: typeScriptOptionsSchema,
+  biome: biomeOptionsSchema,
+  plugins: z.array(pluginConfigSchema).default([])
+});
+
+// src/factory.ts
+function defineFotConfig(config = {}) {
+  const result = fotConfigSchema.safeParse(config);
+  if (!result.success) {
+    const errors = result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join(", ");
+    throw new Error(`Invalid FOT configuration: ${errors}`);
+  }
+  return result.data;
+}
+// src/generators/biome.ts
+function generateBiomeConfig(config) {
+  return {
+    $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+    vcs: {
+      enabled: true,
+      clientKind: "git",
+      useIgnoreFile: true,
+      defaultBranch: "main"
+    },
+    files: {
+      ignoreUnknown: false,
+      ignore: ["node_modules", "dist", "*.config.ts"]
+    },
+    formatter: {
+      enabled: config.biome.enabled,
+      indentStyle: "tab",
+      indentWidth: 2,
+      lineWidth: 80
+    },
+    organizeImports: {
+      enabled: true
+    },
+    linter: {
+      enabled: config.biome.enabled,
+      rules: {
+        recommended: true
+      }
+    },
+    javascript: {
+      formatter: {
+        quoteStyle: "double",
+        semicolons: "always",
+        trailingCommas: "all"
+      }
+    }
+  };
+}
+// src/generators/package-json.ts
+function generatePackageJson(libraryName, version, config, customDependencies) {
+  const exports = {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    }
+  };
+  for (const plugin of config.plugins) {
+    if (plugin.enabled !== false) {
+      exports[`./plugins/${plugin.name}`] = {
+        types: `./dist/plugins/${plugin.name}/index.d.ts`,
+        default: `./dist/plugins/${plugin.name}/index.js`
+      };
+    }
+  }
+  const pkg = {
+    name: `@f-o-t/${libraryName}`,
+    version,
+    type: "module",
+    main: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    exports,
+    scripts: {
+      build: "fot build",
+      test: "fot test",
+      lint: "fot lint",
+      format: "fot format"
+    },
+    devDependencies: {
+      "@f-o-t/cli": "workspace:*",
+      "@f-o-t/config": "workspace:*"
+    },
+    repository: {
+      type: "git",
+      url: "https://github.com/F-O-T/libraries.git",
+      directory: `libraries/${libraryName}`
+    }
+  };
+  if (customDependencies && Object.keys(customDependencies).length > 0) {
+    pkg.dependencies = customDependencies;
+  }
+  return pkg;
+}
+// src/generators/tsconfig.ts
+function generateTSConfig(config) {
+  return {
+    compilerOptions: {
+      allowImportingTsExtensions: true,
+      declaration: config.typescript.declaration,
+      isolatedDeclarations: false,
+      module: "Preserve",
+      moduleDetection: "force",
+      moduleResolution: "bundler",
+      noEmit: true,
+      noFallthroughCasesInSwitch: true,
+      noImplicitOverride: true,
+      noPropertyAccessFromIndexSignature: false,
+      noUncheckedIndexedAccess: true,
+      noUnusedLocals: false,
+      noUnusedParameters: false,
+      skipLibCheck: true,
+      strict: true,
+      target: "ES2023",
+      verbatimModuleSyntax: true
+    },
+    exclude: ["node_modules", "dist", "bunup.config.ts"],
+    include: ["src/**/*"]
+  };
+}
+export {
+  typeScriptOptionsSchema,
+  pluginConfigSchema,
+  generateTSConfig,
+  generatePackageJson,
+  generateBiomeConfig,
+  fotConfigSchema,
+  defineFotConfig,
+  buildFormatSchema,
+  biomeOptionsSchema
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+   "name": "@f-o-t/config",
+   "version": "0.1.0",
+   "description": "Standardized configuration for F-O-T libraries",
+   "type": "module",
+   "module": "./dist/index.js",
+   "types": "./dist/index.d.ts",
+   "exports": {
+      ".": {
+         "bun": "./src/index.ts",
+         "import": {
+            "default": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+         },
+         "types": "./src/index.ts"
+      },
+      "./package.json": "./package.json"
+   },
+   "files": [
+      "dist"
+   ],
+   "scripts": {
+      "build": "bunup",
+      "check": "biome check --write .",
+      "dev": "bunup --watch",
+      "release": "bumpp --commit --push --tag",
+      "test": "bun test",
+      "test:coverage": "bun test --coverage",
+      "test:watch": "bun test --watch",
+      "typecheck": "tsc"
+   },
+   "dependencies": {
+      "zod": "4.3.6"
+   },
+   "devDependencies": {
+      "@biomejs/biome": "2.3.12",
+      "@types/bun": "1.3.6",
+      "bumpp": "10.4.0",
+      "bunup": "0.16.20",
+      "typescript": "5.9.3"
+   },
+   "peerDependencies": {
+      "typescript": ">=4.5.0"
+   },
+   "peerDependenciesMeta": {
+      "typescript": {
+         "optional": true
+      }
+   },
+   "private": false,
+   "publishConfig": {
+      "access": "public"
+   },
+   "repository": {
+      "type": "git",
+      "url": "https://github.com/F-O-T/libraries.git"
+   },
+   "bugs": {
+      "url": "https://github.com/F-O-T/libraries/issues"
+   },
+   "homepage": "https://github.com/F-O-T/libraries/blob/master/libraries/config",
+   "license": "MIT"
+}