@rokkit/cli 1.0.2 → 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jerry Thomas
+
+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/dist/src/config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Load rokkit.config.js using injected adapter or real filesystem.
+ * Returns null (not an error) if config is absent or fails to load.
+ * @param {{ readConfig?: () => Record<string, unknown>, cwd?: string }} adapters
+ * @returns {Promise<Record<string, unknown> | null>}
+ */
+export function loadConfig(adapters: {
+    readConfig?: () => Record<string, unknown>;
+    cwd?: string;
+}): Promise<Record<string, unknown> | null>;

package/dist/src/convert.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Clean up and optimise SVG icon
+ *
+ * @param {string} svg SVG code
+ * @param {boolean} color True if color should be preserved
+ */
+export function cleanAndOptimizeIcon(svg: string, color: boolean): void;
+/**
+ * Process icons
+ *
+ * @param {IconifyTools} iconSet Icon set
+ * @param {boolean} color True if color should be preserved
+ */
+export function processIcons(iconSet: IconifyTools, color: boolean): void;
+/**
+ * Convert individual icons into a json bundle
+ *
+ * @param {string} folder Folder with icons
+ * @param {import('./types').IconBuilderOptions} options Options for conversion
+ * @returns {Promise<object>} The generated icon set
+ */
+export function bundle(folder: string, options: import("./types").IconBuilderOptions): Promise<object>;
+/**
+ * Convert icons to an iconify package
+ *
+ * @param {string} folder Folder with icons
+ * @param {import('./types').IconBuilderOptions} options Options for conversion
+ * @returns {Promise<object>} The generated icon set
+ */
+export function convert(folder: string, options: import("./types").IconBuilderOptions): Promise<object>;
+/**
+ * Read config file from path
+ *
+ * @param {string} configPath Path to config file
+ * @returns {object} Parsed config object
+ */
+export function readConfigFile(configPath: string): object;
+/**
+ * Get folders from directory
+ *
+ * @param {string} dir Directory to scan for folders
+ * @returns {string[]} List of folder names
+ */
+export function getFolderNames(dir: string): string[];
+/**
+ * Converts a folder of icons into an icon bundle
+ * @param {string[]} folders
+ * @param {import('./types').IconBuilderOptions} config
+ * @param {import('./types').FolderOptions}      opts
+ */
+export function bundleFolders(folders: string[], config: import("./types").IconBuilderOptions, opts: import("./types").FolderOptions): void;
+/**
+ * Converts a folder of icons into individual SVG files
+ * @param {string[]}                             folders
+ * @param {import('./types').IconBuilderOptions} config
+ * @param {import('./types').FolderOptions}      opts
+ */
+export function convertFolders(folders: string[], config: import("./types").IconBuilderOptions, opts: import("./types").FolderOptions): void;

package/dist/src/doctor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Run all doctor checks against the given filesystem adapter.
+ * @param {{ exists: (p: string) => boolean, read: (p: string) => string, resolve: (p: string) => string }} fs
+ * @returns {Array<{ id: string, label: string, status: 'pass'|'fail', fixable: boolean, fix: string, autoFix?: string }>}
+ */
+export function runChecks(fs: {
+    exists: (p: string) => boolean;
+    read: (p: string) => string;
+    resolve: (p: string) => string;
+}): Array<{
+    id: string;
+    label: string;
+    status: "pass" | "fail";
+    fixable: boolean;
+    fix: string;
+    autoFix?: string;
+}>;
+/**
+ * Interactive doctor command — validates project setup.
+ * @param {{ fix?: boolean }} [opts]
+ */
+export function doctor(opts?: {
+    fix?: boolean;
+}): void;

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/init.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Detect if the current directory is a SvelteKit project.
+ * @param {string} cwd
+ * @returns {boolean}
+ */
+export function detectSvelteKit(cwd: string): boolean;
+/**
+ * Install Rokkit packages via the detected package manager.
+ * Skips packages already in package.json.
+ * @param {string} cwd
+ * @param {{ runInstall?: (bin: string, args: string[]) => void }} [adapters]
+ */
+export function installPackages(cwd: string, adapters?: {
+    runInstall?: (bin: string, args: string[]) => void;
+}): void;
+/**
+ * Build the chart config section from user prompt answers.
+ * @param {{ chartColors: string, chartShades: string }} opts
+ * @returns {Record<string, unknown>}
+ */
+export function generateChartConfig({ chartColors, chartShades }: {
+    chartColors: string;
+    chartShades: string;
+}): Record<string, unknown>;
+export function generateConfig({ palette, customColors, icons, iconPath, iconStyle, themes, defaultTheme, switcher, includeChart, chartColors, chartShades }: {
+    palette: any;
+    customColors: any;
+    icons: any;
+    iconPath: any;
+    iconStyle: any;
+    themes: any;
+    defaultTheme: any;
+    switcher: any;
+    includeChart: any;
+    chartColors: any;
+    chartShades: any;
+}): {
+    colors: Record<string, unknown>;
+    themes: any;
+    defaultTheme: any;
+    switcher: any;
+    storageKey: string;
+};
+/**
+ * Generate the content for uno.config.js.
+ * @returns {string}
+ */
+export function generateUnoConfig(): string;
+/**
+ * Generate an array of CSS @import lines for app.css.
+ * @param {string[]} themes
+ * @returns {string[]}
+ */
+export function generateAppCssImports(themes: string[]): string[];
+/**
+ * Generate the flash-prevention script for app.html.
+ * Returns null when no script is needed (system switcher).
+ * @param {string} switcher — 'system' | 'manual' | 'full'
+ * @param {string} [storageKey='rokkit-theme']
+ * @returns {string | null}
+ */
+export function generateInitScript(switcher: string, storageKey?: string, defaultStyle?: string): string | null;
+/**
+ * Interactive init command — prompts the user, writes config files.
+ * @param {Record<string, unknown>} [_opts]
+ * @param {{ runInstall?: (bin: string, args: string[]) => void }} [adapters] — injectable for testing
+ */
+export function init(_opts?: Record<string, unknown>, adapters?: {
+    runInstall?: (bin: string, args: string[]) => void;
+}): Promise<void>;

package/dist/src/skin.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Generate a skin scaffold object with all token keys set to default color names.
+ * @returns {Record<string, string>}
+ */
+export function generateSkinScaffold(): Record<string, string>;
+/**
+ * Add a new skin entry to a config object (pure, no side effects).
+ * @param {Record<string, unknown>} config
+ * @param {string} name
+ * @returns {Record<string, unknown>}
+ */
+export function addSkinToConfig(config: Record<string, unknown>, name: string): Record<string, unknown>;
+/**
+ * Serialize a rokkit config back to a JS module string.
+ * @param {Record<string, unknown>} config
+ * @returns {string}
+ */
+export function serializeConfig(config: Record<string, unknown>): string;
+export function runSkinList(adapters?: {}): Promise<void>;
+export function runSkinCreate(name: any, adapters?: {}): Promise<void>;
+/**
+ * CLI entry point for `rokkit skin` subcommands.
+ * @param {string} sub — 'list' | 'create'
+ * @param {{ name?: string }} opts
+ */
+export function skin(sub: string, opts?: {
+    name?: string;
+}): Promise<void>;

package/dist/src/theme.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generate a full CSS theme stub for the given style name.
+ * Produces one `[data-style='<name>']` block per component.
+ * @param {string} name
+ * @returns {string}
+ */
+export function generateThemeStub(name: string): string;
+export function runThemeList(adapters?: {}): Promise<void>;
+export function runThemeCreate(name: any, adapters?: {}): void;
+/**
+ * CLI entry point for `rokkit theme` subcommands.
+ * @param {string} sub — 'list' | 'create'
+ * @param {{ name?: string }} opts
+ */
+export function theme(sub: string, opts?: {
+    name?: string;
+}): Promise<void>;
+/**
+ * All component names that ship with Rokkit — one CSS block will be generated for each.
+ */
+export const THEME_COMPONENTS: string[];

package/dist/src/types.d.ts

@@ -0,0 +1,24 @@
+export type IconPackageInfo = {
+    namespace?: string | undefined;
+    version?: string | undefined;
+    homepage?: string | undefined;
+};
+export type BundleConfig = {
+    color?: boolean | undefined;
+};
+export type BundleConfiguration = {
+    package?: IconPackageInfo | undefined;
+    bundles?: {
+        [x: string]: BundleConfig;
+    } | undefined;
+};
+export type IconBuilderOptions = {
+    target: string;
+    prefix: string;
+    color: boolean;
+    package?: IconPackageInfo | undefined;
+};
+export type FolderOptions = {
+    input: string;
+    output: string;
+};

package/dist/src/upgrade.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Extract @rokkit/* packages from a parsed package.json object.
+ * @param {Record<string, unknown>} pkgJson
+ * @returns {{ name: string, current: string }[]}
+ */
+export function getRokkitPackages(pkgJson: Record<string, unknown>): {
+    name: string;
+    current: string;
+}[];
+/**
+ * Detect the package manager from lockfile presence.
+ * @param {string[]} lockfiles — list of lockfile names that exist in cwd
+ * @returns {'bun' | 'pnpm' | 'yarn' | 'npm'}
+ */
+export function detectPackageManager(lockfiles: string[]): "bun" | "pnpm" | "yarn" | "npm";
+/**
+ * Build the install command for the given package manager.
+ * @param {'bun' | 'pnpm' | 'yarn' | 'npm'} pm
+ * @param {string[]} packages — package specs like `@rokkit/ui@1.2.3`
+ * @returns {{ bin: string, args: string[] }}
+ */
+export function buildInstallCommand(pm: "bun" | "pnpm" | "yarn" | "npm", packages: string[]): {
+    bin: string;
+    args: string[];
+};
+export function runUpgrade(opts?: {}, adapters?: {}): void;
+/**
+ * CLI entry point for `rokkit upgrade`
+ * @param {{ apply?: boolean }} opts
+ */
+export function upgrade(opts?: {
+    apply?: boolean;
+}): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Command line utilities for icon bundling and conversion.",
   "repository": {
     "type": "git",