@a35hie/ts-pkg 0.1.0 → 0.1.2

package/README.md

@@ -1,4 +1,4 @@
-# ts-pkg-config
+# TS Package Config
 
 ✨ TypeScript-based `package.json` with magical features.
 
@@ -70,9 +70,9 @@ export default definePackageConfig({
 Generate your `package.json`:
 
 ```bash
-bun run ts-pkg-config
+bunx ts-pkg
 # or
-bun run src/main.ts package.config.ts package.json
+bunx ts-pkg package.config.ts package.json
 ```
 
 ## Script Presets

package/build.ts

@@ -1,5 +1,6 @@
 import dts from 'bun-plugin-dts'
 
+// Build library
 await Bun.build({
   entrypoints: ['./src/main.ts'],
   outdir: './dist',
@@ -11,4 +12,15 @@ await Bun.build({
   plugins: [dts()],
 })
 
+// Build CLI
+await Bun.build({
+  entrypoints: ['./src/cli.ts'],
+  outdir: './dist',
+  format: 'esm',
+  target: 'node',
+  splitting: false,
+  minify: false,
+  banner: '#!/usr/bin/env bun',
+})
+
 console.log('✨ Build complete')

package/dist/cli.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env bun
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/presets/scripts.ts
+var scriptPresets = {
+  typescript: {
+    build: "tsc",
+    "build:watch": "tsc --watch",
+    typecheck: "tsc --noEmit"
+  },
+  react: {
+    dev: "vite",
+    build: "vite build",
+    preview: "vite preview"
+  },
+  node: {
+    start: "node dist/index.js",
+    dev: "tsx watch src/index.ts",
+    build: "tsup src/index.ts --format esm,cjs --dts"
+  },
+  testing: {
+    test: "vitest",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest --coverage"
+  },
+  prettier: {
+    format: "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  eslint: {
+    lint: "eslint .",
+    "lint:fix": "eslint . --fix"
+  }
+};
+function getPresetScripts(presets) {
+  const merged = {};
+  for (const preset of presets) {
+    const scripts = scriptPresets[preset];
+    if (scripts) {
+      Object.assign(merged, scripts);
+    }
+  }
+  return merged;
+}
+function mergeScripts(presetScripts, customScripts) {
+  return { ...presetScripts, ...customScripts };
+}
+
+// src/resolvers/dependencies.ts
+function parseDependency(dep) {
+  if (typeof dep === "string") {
+    const atIndex = dep.lastIndexOf("@");
+    if (atIndex > 0) {
+      return {
+        name: dep.slice(0, atIndex),
+        version: dep.slice(atIndex + 1)
+      };
+    }
+    return { name: dep };
+  }
+  const [name, version] = Object.entries(dep)[0];
+  return { name, version };
+}
+async function fetchLatestVersion(packageName) {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}`;
+  const response = await fetch(url, {
+    headers: { Accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${packageName}: ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data["dist-tags"].latest;
+}
+var versionCache = new Map;
+async function resolveDependenciesCached(deps) {
+  if (!deps) {
+    return {};
+  }
+  if (!Array.isArray(deps)) {
+    return deps;
+  }
+  if (deps.length === 0) {
+    return {};
+  }
+  const results = [];
+  for (const dep of deps) {
+    const { name, version } = parseDependency(dep);
+    if (version) {
+      results.push([name, version]);
+      continue;
+    }
+    let resolvedVersion = versionCache.get(name);
+    if (!resolvedVersion) {
+      resolvedVersion = `^${await fetchLatestVersion(name)}`;
+      versionCache.set(name, resolvedVersion);
+    }
+    results.push([name, resolvedVersion]);
+  }
+  return Object.fromEntries(results);
+}
+
+// src/utils/merge.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue === undefined)
+      continue;
+    if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function mergeDependencies(target, source) {
+  if (!target && !source)
+    return;
+  if (!target)
+    return source;
+  if (!source)
+    return target;
+  if (Array.isArray(target) && Array.isArray(source)) {
+    return [...target, ...source];
+  }
+  if (!Array.isArray(target) && !Array.isArray(source)) {
+    return { ...target, ...source };
+  }
+  const targetObj = Array.isArray(target) ? {} : target;
+  const sourceObj = Array.isArray(source) ? {} : source;
+  const targetArr = Array.isArray(target) ? target : [];
+  const sourceArr = Array.isArray(source) ? source : [];
+  return [...targetArr, ...sourceArr, { ...targetObj, ...sourceObj }];
+}
+async function resolveExtends(config) {
+  if (!config.extends) {
+    return config;
+  }
+  let baseConfig;
+  if (typeof config.extends === "string") {
+    const imported = await import(config.extends);
+    baseConfig = imported.default ?? imported;
+  } else {
+    baseConfig = config.extends;
+  }
+  baseConfig = await resolveExtends(baseConfig);
+  const { extends: _, ...currentWithoutExtends } = config;
+  return {
+    ...baseConfig,
+    ...currentWithoutExtends,
+    dependencies: mergeDependencies(baseConfig.dependencies, currentWithoutExtends.dependencies),
+    devDependencies: mergeDependencies(baseConfig.devDependencies, currentWithoutExtends.devDependencies),
+    peerDependencies: mergeDependencies(baseConfig.peerDependencies, currentWithoutExtends.peerDependencies),
+    scripts: { ...baseConfig.scripts, ...currentWithoutExtends.scripts },
+    scriptPresets: [
+      ...baseConfig.scriptPresets ?? [],
+      ...currentWithoutExtends.scriptPresets ?? []
+    ]
+  };
+}
+
+// src/utils/conditions.ts
+function getContext() {
+  return {
+    env: "development",
+    platform: process.platform,
+    nodeVersion: process.version,
+    ci: process.env.CI === "true" || process.env.CI === "1"
+  };
+}
+function evaluateCondition(when, context) {
+  if (when.env !== undefined && context.env !== when.env) {
+    return false;
+  }
+  if (when.platform !== undefined && context.platform !== when.platform) {
+    return false;
+  }
+  if (when.ci !== undefined && context.ci !== when.ci) {
+    return false;
+  }
+  if (when.nodeVersion !== undefined) {
+    if (!context.nodeVersion.startsWith(when.nodeVersion)) {
+      return false;
+    }
+  }
+  return true;
+}
+function applyConditions(baseConfig, conditions) {
+  if (!conditions || conditions.length === 0) {
+    return baseConfig;
+  }
+  const context = getContext();
+  let result = { ...baseConfig };
+  for (const condition of conditions) {
+    if (evaluateCondition(condition.when, context)) {
+      result = deepMerge(result, condition.set);
+    }
+  }
+  return result;
+}
+
+// src/generator/createPackageJson.ts
+async function createPackageJson(config, options = {}) {
+  const { indent = 2 } = options;
+  let resolved = await resolveExtends(config);
+  const presetScripts = resolved.scriptPresets ? getPresetScripts(resolved.scriptPresets) : {};
+  const finalScripts = mergeScripts(presetScripts, resolved.scripts);
+  const [dependencies, devDependencies, peerDependencies] = await Promise.all([
+    resolveDependenciesCached(resolved.dependencies),
+    resolveDependenciesCached(resolved.devDependencies),
+    resolveDependenciesCached(resolved.peerDependencies)
+  ]);
+  const packageJson = {
+    name: resolved.name,
+    ...resolved.version && { version: resolved.version },
+    ...resolved.description && { description: resolved.description },
+    ...resolved.keywords?.length && { keywords: resolved.keywords },
+    ...resolved.homepage && { homepage: resolved.homepage },
+    ...resolved.bugs && { bugs: resolved.bugs },
+    ...resolved.license && { license: resolved.license },
+    ...resolved.author && { author: resolved.author },
+    ...resolved.contributors?.length && {
+      contributors: resolved.contributors
+    },
+    ...resolved.repository && { repository: resolved.repository },
+    ...resolved.type && { type: resolved.type },
+    ...resolved.main && { main: resolved.main },
+    ...resolved.module && { module: resolved.module },
+    ...resolved.types && { types: resolved.types },
+    ...resolved.exports && { exports: resolved.exports },
+    ...resolved.bin && { bin: resolved.bin },
+    ...resolved.files?.length && { files: resolved.files },
+    ...Object.keys(finalScripts).length && { scripts: finalScripts },
+    ...Object.keys(dependencies).length && { dependencies },
+    ...Object.keys(devDependencies).length && { devDependencies },
+    ...Object.keys(peerDependencies).length && { peerDependencies },
+    ...resolved.optionalDependencies && {
+      optionalDependencies: resolved.optionalDependencies
+    },
+    ...resolved.engines && { engines: resolved.engines },
+    ...resolved.os?.length && { os: resolved.os },
+    ...resolved.cpu?.length && { cpu: resolved.cpu },
+    ...resolved.private !== undefined && { private: resolved.private },
+    ...resolved.publishConfig && { publishConfig: resolved.publishConfig },
+    ...resolved.workspaces?.length && { workspaces: resolved.workspaces }
+  };
+  const finalPackageJson = applyConditions(packageJson, resolved.conditions);
+  return JSON.stringify(finalPackageJson, null, indent);
+}
+async function writePackageJson(config, options = {}) {
+  const { outputPath = "package.json" } = options;
+  const json = await createPackageJson(config, options);
+  const { writeFile } = await import("node:fs/promises");
+  await writeFile(outputPath, json + `
+`);
+  console.log(`✨ Generated ${outputPath}`);
+}
+
+// src/cli.ts
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+async function main() {
+  const configPath = process.argv[2] ?? "package.config.ts";
+  const outputPath = process.argv[3] ?? "package.json";
+  const absoluteConfigPath = resolve(process.cwd(), configPath);
+  try {
+    const configModule = await import(pathToFileURL(absoluteConfigPath).href);
+    const config = configModule.default ?? configModule;
+    await writePackageJson(config, { outputPath });
+  } catch (error) {
+    const err = error;
+    if (err.code === "ERR_MODULE_NOT_FOUND" || err.code === "ENOENT") {
+      console.error(`❌ Config file not found: ${configPath}`);
+      console.error(`
+Create a package.config.ts file with:`);
+      console.error(`
+import { definePackageConfig } from '@a35hie/ts-pkg'
+
+export default definePackageConfig({
+  name: 'my-package',
+  version: '1.0.0',
+  scriptPresets: ['typescript', 'testing'],
+  dependencies: ['lodash', 'zod'],
+  devDependencies: ['typescript', 'vitest'],
+})
+`);
+      process.exit(1);
+    }
+    console.error("❌ Error:", err.message);
+    process.exit(1);
+  }
+}
+main();

package/dist/main.d.ts

@@ -1,147 +1,87 @@
 // Generated by dts-bundle-generator v9.5.1
 
-export type License =
-  | 'MIT'
-  | 'Apache-2.0'
-  | 'GPL-2.0-only'
-  | 'GPL-2.0-or-later'
-  | 'GPL-3.0-only'
-  | 'GPL-3.0-or-later'
-  | 'LGPL-2.1-only'
-  | 'LGPL-2.1-or-later'
-  | 'LGPL-3.0-only'
-  | 'LGPL-3.0-or-later'
-  | 'BSD-2-Clause'
-  | 'BSD-3-Clause'
-  | 'ISC'
-  | 'MPL-2.0'
-  | 'AGPL-3.0-only'
-  | 'AGPL-3.0-or-later'
-  | 'Unlicense'
-  | 'WTFPL'
-  | 'CC0-1.0'
-  | 'CC-BY-4.0'
-  | 'CC-BY-SA-4.0'
-  | 'Zlib'
-  | 'BSL-1.0'
-  | 'EPL-2.0'
-  | 'EUPL-1.2'
-  | 'CDDL-1.0'
-  | 'Artistic-2.0'
-  | 'OSL-3.0'
-  | 'AFL-3.0'
-  | 'LPPL-1.3c'
-  | (string & {})
+export type License = "MIT" | "Apache-2.0" | "GPL-2.0-only" | "GPL-2.0-or-later" | "GPL-3.0-only" | "GPL-3.0-or-later" | "LGPL-2.1-only" | "LGPL-2.1-or-later" | "LGPL-3.0-only" | "LGPL-3.0-or-later" | "BSD-2-Clause" | "BSD-3-Clause" | "ISC" | "MPL-2.0" | "AGPL-3.0-only" | "AGPL-3.0-or-later" | "Unlicense" | "WTFPL" | "CC0-1.0" | "CC-BY-4.0" | "CC-BY-SA-4.0" | "Zlib" | "BSL-1.0" | "EPL-2.0" | "EUPL-1.2" | "CDDL-1.0" | "Artistic-2.0" | "OSL-3.0" | "AFL-3.0" | "LPPL-1.3c" | (string & {});
 export interface StandardPackageJson {
-  name: string
-  version?: string
-  description?: string
-  keywords?: string[]
-  homepage?: string
-  bugs?:
-    | string
-    | {
-        url?: string
-        email?: string
-      }
-  license?: License
-  author?:
-    | string
-    | {
-        name: string
-        email?: string
-        url?: string
-      }
-  contributors?: (
-    | string
-    | {
-        name: string
-        email?: string
-        url?: string
-      }
-  )[]
-  repository?:
-    | string
-    | {
-        type: string
-        url: string
-        directory?: string
-      }
-  main?: string
-  module?: string
-  types?: string
-  exports?: Record<
-    string,
-    | string
-    | {
-        import?: string
-        require?: string
-        types?: string
-      }
-  >
-  bin?: string | Record<string, string>
-  files?: string[]
-  scripts?: Record<string, string>
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-  peerDependencies?: Record<string, string>
-  optionalDependencies?: Record<string, string>
-  engines?: Record<string, string>
-  os?: string[]
-  cpu?: string[]
-  private?: boolean
-  publishConfig?: Record<string, unknown>
-  workspaces?: string[]
-  type?: 'module' | 'commonjs'
+	name: string;
+	version?: string;
+	description?: string;
+	keywords?: string[];
+	homepage?: string;
+	bugs?: string | {
+		url?: string;
+		email?: string;
+	};
+	license?: License;
+	author?: string | {
+		name: string;
+		email?: string;
+		url?: string;
+	};
+	contributors?: (string | {
+		name: string;
+		email?: string;
+		url?: string;
+	})[];
+	repository?: string | {
+		type: string;
+		url: string;
+		directory?: string;
+	};
+	main?: string;
+	module?: string;
+	types?: string;
+	exports?: Record<string, string | {
+		import?: string;
+		require?: string;
+		types?: string;
+	}>;
+	bin?: string | Record<string, string>;
+	files?: string[];
+	scripts?: Record<string, string>;
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+	peerDependencies?: Record<string, string>;
+	optionalDependencies?: Record<string, string>;
+	engines?: Record<string, string>;
+	os?: string[];
+	cpu?: string[];
+	private?: boolean;
+	publishConfig?: Record<string, unknown>;
+	workspaces?: string[];
+	type?: "module" | "commonjs";
 }
-export type ScriptPreset =
-  | 'typescript'
-  | 'react'
-  | 'node'
-  | 'testing'
-  | 'prettier'
-  | 'eslint'
-export type DependencyInput = string | Record<string, string>
+export type ScriptPreset = "typescript" | "react" | "node" | "testing" | "prettier" | "eslint";
+export type DependencyInput = string | Record<string, string>;
+export type DependenciesInput = DependencyInput[] | Record<string, string>;
 export interface ConditionalConfig {
-  when: {
-    env?: string
-    platform?: NodeJS.Platform
-    nodeVersion?: string
-    ci?: boolean
-  }
-  set: Partial<StandardPackageJson>
+	when: {
+		env?: string;
+		platform?: NodeJS.Platform;
+		nodeVersion?: string;
+		ci?: boolean;
+	};
+	set: Partial<StandardPackageJson>;
 }
-export interface PackageConfig extends Omit<
-  StandardPackageJson,
-  'scripts' | 'dependencies' | 'devDependencies' | 'peerDependencies'
-> {
-  extends?: string | PackageConfig
-  scriptPresets?: ScriptPreset[]
-  scripts?: Record<string, string>
-  dependencies?: DependencyInput[]
-  devDependencies?: DependencyInput[]
-  peerDependencies?: DependencyInput[]
-  conditions?: ConditionalConfig[]
-  autoInfer?: {
-    version?: boolean
-    repository?: boolean
-    author?: boolean
-  }
+export interface PackageConfig extends Omit<StandardPackageJson, "scripts" | "dependencies" | "devDependencies" | "peerDependencies"> {
+	extends?: string | PackageConfig;
+	scriptPresets?: ScriptPreset[];
+	scripts?: Record<string, string>;
+	dependencies?: DependenciesInput;
+	devDependencies?: DependenciesInput;
+	peerDependencies?: DependenciesInput;
+	conditions?: ConditionalConfig[];
+	autoInfer?: {
+		version?: boolean;
+		repository?: boolean;
+		author?: boolean;
+	};
 }
 export interface GenerateOptions {
-  indent?: number
-  outputPath?: string
+	indent?: number;
+	outputPath?: string;
 }
-export declare function createPackageJson(
-  config: PackageConfig,
-  options?: GenerateOptions
-): Promise<string>
-export declare function writePackageJson(
-  config: PackageConfig,
-  options?: GenerateOptions
-): Promise<void>
-export declare function definePackageConfig(
-  config: PackageConfig
-): PackageConfig
+export declare function createPackageJson(config: PackageConfig, options?: GenerateOptions): Promise<string>;
+export declare function writePackageJson(config: PackageConfig, options?: GenerateOptions): Promise<void>;
+export declare function definePackageConfig(config: PackageConfig): PackageConfig;
 
-export {}
+export {};