@75neo/ui 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 75Neo
+
+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,85 @@
+# @75neo/ui
+
+The installer and animation stylesheet for [75NeoUI](https://75neo-ui.pages.dev), a component
+library for React and Vue.
+
+## Install
+
+```sh
+npx @75neo/ui@latest init
+npx @75neo/ui@latest add button
+```
+
+`init` detects whether the project is React or Vue, writes a `75neoui.json`, and adds the theme
+tokens and this package's animation stylesheet to your Tailwind entry file. `add` writes component
+source into your project and installs the npm packages it declares.
+
+## Commands
+
+| Command         | What it does                                          |
+| --------------- | ----------------------------------------------------- |
+| `init`          | Set the project up and write `75neoui.json`           |
+| `add <items..>` | Add components, resolving their registry dependencies |
+| `add --all`     | Add every component                                   |
+| `list`          | List the components in the registry                   |
+
+Every command takes `--cwd` and `--registry`. `init` also takes `--framework`, `--css` and
+`--overwrite`; `add` takes `--all` and `--overwrite`. Pass `--no-install` to skip npm installs.
+
+## Programmatic API
+
+The package is written in TypeScript and ships type declarations. Every command is also available
+as a function, so a script can drive the installer directly.
+
+```ts
+import { readConfig, resolveItems, writeFiles } from "@75neo/ui";
+
+const config = await readConfig(process.cwd());
+const items = await resolveItems(config.registry, config.framework, ["button"]);
+const { written, skipped } = await writeFiles(items, config, {
+  cwd: process.cwd(),
+  overwrite: false,
+});
+```
+
+Registry responses and `75neoui.json` are validated against the package's own zod schemas rather
+than cast, so a malformed document fails with a message naming the field instead of surfacing
+later as a crash. The schemas are exported too, and `jsonSchemas()` renders them as JSON Schema.
+
+```ts
+import { registryItemSchema, validate } from "@75neo/ui";
+
+const item = validate(registryItemSchema, "button.json", await response.json());
+```
+
+## Stylesheet
+
+```css
+@import "tailwindcss";
+@import "@75neo/ui/animations.css";
+```
+
+The stylesheet carries the keyframes and `--animate-*` entries that overlay components use. Design
+tokens are not here on purpose: `init` writes those into your own stylesheet so you can override
+them.
+
+## Releasing
+
+The first publish of a new package must be manual, because npm only lets a trusted publisher be
+configured on a package that already exists.
+
+```sh
+cd packages/ui
+pnpm publish --access public --no-git-checks
+```
+
+After that, configure trusted publishing once, either on the package's access page at npmjs.com or
+with the npm CLI:
+
+```sh
+npm trust github @75neo/ui --repo 75Neo/ui --file release.yml --allow-publish
+```
+
+From then on, publishing a GitHub release named `v<version>` runs `.github/workflows/release.yml`,
+which authenticates over OIDC with no token stored anywhere. The workflow refuses to run when the
+release tag and the package version disagree.

package/animations.css

@@ -0,0 +1,90 @@
+@theme {
+  --animate-panel-in: panel-in 0.15s ease-out;
+  --animate-panel-out: panel-out 0.1s ease-in;
+  --animate-fade-in: fade-in 0.15s ease-out;
+  --animate-fade-out: fade-out 0.1s ease-in;
+  --animate-dialog-in: dialog-in 0.15s cubic-bezier(0.16, 1, 0.3, 1);
+  --animate-dialog-out: dialog-out 0.1s ease-in;
+  --animate-drawer-in: drawer-in 0.2s cubic-bezier(0.16, 1, 0.3, 1);
+  --animate-drawer-out: drawer-out 0.15s ease-in;
+
+  @keyframes panel-in {
+    from {
+      opacity: 0;
+      transform: translateY(-0.25rem);
+    }
+    to {
+      opacity: 1;
+      transform: translateY(0);
+    }
+  }
+
+  @keyframes panel-out {
+    from {
+      opacity: 1;
+      transform: translateY(0);
+    }
+    to {
+      opacity: 0;
+      transform: translateY(-0.25rem);
+    }
+  }
+
+  @keyframes fade-in {
+    from {
+      opacity: 0;
+    }
+    to {
+      opacity: 1;
+    }
+  }
+
+  @keyframes fade-out {
+    from {
+      opacity: 1;
+    }
+    to {
+      opacity: 0;
+    }
+  }
+
+  @keyframes dialog-in {
+    from {
+      opacity: 0;
+      transform: scale(0.96);
+    }
+    to {
+      opacity: 1;
+      transform: scale(1);
+    }
+  }
+
+  @keyframes dialog-out {
+    from {
+      opacity: 1;
+      transform: scale(1);
+    }
+    to {
+      opacity: 0;
+      transform: scale(0.96);
+    }
+  }
+
+  @keyframes drawer-in {
+    from {
+      translate: var(--drawer-from);
+    }
+    to {
+      translate: 0 0;
+    }
+  }
+
+  @keyframes drawer-out {
+    from {
+      translate: 0 0;
+    }
+    to {
+      translate: var(--drawer-from);
+    }
+  }
+}

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { C as detectFramework, D as FRAMEWORKS, E as writeConfig, S as detectCssEntry, T as readConfig, _ as CONFIG_FILE, a as resolveItems, c as detectPackageManager, g as withTheme, h as withImport, i as fetchItem, k as ValidationError, l as install, n as collectDependencies, p as writeFiles, r as fetchIndex, t as RegistryError, u as InstallError, v as ConfigError, w as detectPaths, x as configPath, y as DEFAULT_ALIASES } from "./registry-C1lAzYLJ.mjs";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+//#region src/cli.ts
+const PACKAGE = "@75neo/ui";
+const ANIMATIONS = `${PACKAGE}/animations.css`;
+const THEME_MARKER = "/* 75NeoUI theme */";
+const green = (text) => `\x1b[32m${text}\x1b[0m`;
+const red = (text) => `\x1b[31m${text}\x1b[0m`;
+const dim = (text) => `\x1b[2m${text}\x1b[0m`;
+const bold = (text) => `\x1b[1m${text}\x1b[0m`;
+async function updateStylesheet(cwd, config, css) {
+	const stylesheet = path.join(cwd, config.css);
+	const source = await readFile(stylesheet, "utf8");
+	const next = withTheme(withImport(source, ANIMATIONS), css, THEME_MARKER);
+	if (next === source) return false;
+	await writeFile(stylesheet, next);
+	return true;
+}
+async function runInit(args) {
+	const cwd = path.resolve(args.cwd);
+	if (existsSync(configPath(cwd)) && !args.overwrite) throw new ConfigError(`${CONFIG_FILE} already exists. Pass --overwrite to replace it.`);
+	const framework = args.framework ?? await detectFramework(cwd);
+	if (framework === null || framework === void 0) throw new ConfigError(`Could not tell whether this is a React or Vue project. Pass --framework ${FRAMEWORKS.join(" or --framework ")}.`);
+	const css = args.css ?? await detectCssEntry(cwd);
+	if (css === null || css === void 0) throw new ConfigError("Could not find a stylesheet importing \"tailwindcss\". Pass --css with the path to it.");
+	const config = {
+		framework,
+		css,
+		registry: args.registry ?? "https://75neo-ui.pages.dev/r",
+		paths: detectPaths(cwd),
+		aliases: DEFAULT_ALIASES
+	};
+	await writeConfig(cwd, config);
+	console.log(`${green("done")} wrote ${CONFIG_FILE}`);
+	const theme = await fetchItem(config.registry, framework, "theme");
+	if (theme.css === void 0) throw new RegistryError("The theme item carries no CSS, so there are no tokens to write.");
+	await updateStylesheet(cwd, config, theme.css);
+	console.log(`${green("done")} updated ${css}`);
+	if (!args.install) return;
+	const manager = detectPackageManager(cwd);
+	console.log(dim(`${manager} add ${PACKAGE}`));
+	await install([PACKAGE], {
+		cwd,
+		manager
+	});
+}
+async function runAdd(args) {
+	const cwd = path.resolve(args.cwd);
+	const config = await readConfig(cwd);
+	const registry = args.registry ?? config.registry;
+	let names = args.items;
+	if (args.all) names = (await fetchIndex(registry, config.framework)).items.filter((item) => item.type === "registry:ui").map((item) => item.name);
+	if (names.length === 0) throw new RegistryError("Name at least one component, or pass --all.");
+	const items = await resolveItems(registry, config.framework, names);
+	const { written, skipped } = await writeFiles(items, config, {
+		cwd,
+		overwrite: args.overwrite
+	});
+	for (const file of written) console.log(`${green("done")} ${file}`);
+	for (const file of skipped) console.log(dim(`kept ${file}, pass --overwrite to replace it`));
+	const theme = items.find((item) => item.type === "registry:theme");
+	if (theme?.css !== void 0 && await updateStylesheet(cwd, config, theme.css)) console.log(`${green("done")} updated ${config.css}`);
+	if (!args.install) return;
+	const dependencies = collectDependencies(items);
+	if (dependencies.length === 0) return;
+	const manager = detectPackageManager(cwd);
+	console.log(dim(`${manager} add ${dependencies.join(" ")}`));
+	await install(dependencies, {
+		cwd,
+		manager
+	});
+}
+async function runList(args) {
+	const cwd = path.resolve(args.cwd);
+	const framework = args.framework ?? (await readConfig(cwd)).framework;
+	const index = await fetchIndex(args.registry ?? "https://75neo-ui.pages.dev/r", framework);
+	for (const item of index.items) {
+		if (item.type !== "registry:ui") continue;
+		console.log(`${bold(item.name.padEnd(18))}${item.description ?? ""}`);
+	}
+}
+function fail(error) {
+	const known = error instanceof ConfigError || error instanceof RegistryError || error instanceof InstallError || error instanceof ValidationError;
+	const message = error instanceof Error ? known ? error.message : error.stack ?? error.message : String(error);
+	console.error(red(message));
+	process.exitCode = 1;
+}
+const run = (handler) => (args) => {
+	handler(args).catch(fail);
+};
+await yargs(hideBin(process.argv)).scriptName("75neoui").usage("$0 <command> [options]").options({
+	cwd: {
+		type: "string",
+		default: process.cwd(),
+		describe: "Project directory to work in"
+	},
+	registry: {
+		type: "string",
+		describe: "Registry base URL or local directory"
+	}
+}).command("init", "Set the project up for 75NeoUI", (builder) => builder.options({
+	framework: {
+		type: "string",
+		choices: FRAMEWORKS,
+		describe: "Framework to install for"
+	},
+	css: {
+		type: "string",
+		describe: "Path to the Tailwind entry stylesheet"
+	},
+	overwrite: {
+		type: "boolean",
+		default: false,
+		describe: `Replace an existing ${CONFIG_FILE}`
+	},
+	install: {
+		type: "boolean",
+		default: true,
+		describe: "Install npm dependencies"
+	}
+}), run(runInit)).command("add [items..]", "Add components to the project", (builder) => builder.positional("items", {
+	type: "string",
+	array: true,
+	default: []
+}).options({
+	all: {
+		type: "boolean",
+		default: false,
+		describe: "Add every component"
+	},
+	overwrite: {
+		type: "boolean",
+		default: false,
+		describe: "Replace files that already exist"
+	},
+	install: {
+		type: "boolean",
+		default: true,
+		describe: "Install npm dependencies"
+	}
+}), run(runAdd)).command("list", "List the components in the registry", (builder) => builder.options({ framework: {
+	type: "string",
+	choices: FRAMEWORKS,
+	describe: "Framework to list"
+} }), run(runList)).demandCommand(1, "Name a command. Try `75neoui --help`.").strict().help().alias("h", "help").version().wrap(Math.min(100, process.stdout.columns ?? 100)).parseAsync();
+//#endregion
+export {};

package/dist/index.d.mts

@@ -0,0 +1,215 @@
+import { z } from "zod";
+//#region src/schema.d.ts
+export declare const FRAMEWORKS: readonly ["react", "vue"];
+export declare const ITEM_TYPES: readonly ["registry:ui", "registry:lib", "registry:theme"];
+export declare const frameworkSchema: z.ZodEnum<{
+  react: "react";
+  vue: "vue";
+}>;
+export declare const itemTypeSchema: z.ZodEnum<{
+  "registry:ui": "registry:ui";
+  "registry:lib": "registry:lib";
+  "registry:theme": "registry:theme";
+}>;
+export declare const cssBlockSchema: z.ZodRecord<z.ZodString, z.ZodType<CssValue, unknown, z.core.$ZodTypeInternals<CssValue, unknown>>>;
+export declare const registryFileSchema: z.ZodObject<{
+  path: z.ZodString;
+  type: z.ZodEnum<{
+    "registry:ui": "registry:ui";
+    "registry:lib": "registry:lib";
+    "registry:theme": "registry:theme";
+  }>;
+  content: z.ZodString;
+}, z.core.$strip>;
+export declare const registryFileEntrySchema: z.ZodObject<{
+  type: z.ZodEnum<{
+    "registry:ui": "registry:ui";
+    "registry:lib": "registry:lib";
+    "registry:theme": "registry:theme";
+  }>;
+  path: z.ZodString;
+}, z.core.$strip>;
+export declare const registryItemSchema: z.ZodObject<{
+  name: z.ZodString;
+  type: z.ZodEnum<{
+    "registry:ui": "registry:ui";
+    "registry:lib": "registry:lib";
+    "registry:theme": "registry:theme";
+  }>;
+  title: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  css: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<CssValue, unknown, z.core.$ZodTypeInternals<CssValue, unknown>>>>;
+  docs: z.ZodOptional<z.ZodString>;
+  files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodEnum<{
+      "registry:ui": "registry:ui";
+      "registry:lib": "registry:lib";
+      "registry:theme": "registry:theme";
+    }>;
+    content: z.ZodString;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const registryIndexEntrySchema: z.ZodObject<{
+  name: z.ZodString;
+  type: z.ZodEnum<{
+    "registry:ui": "registry:ui";
+    "registry:lib": "registry:lib";
+    "registry:theme": "registry:theme";
+  }>;
+  title: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const registryIndexSchema: z.ZodObject<{
+  name: z.ZodString;
+  homepage: z.ZodOptional<z.ZodString>;
+  items: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+      "registry:ui": "registry:ui";
+      "registry:lib": "registry:lib";
+      "registry:theme": "registry:theme";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const pathsSchema: z.ZodObject<{
+  ui: z.ZodString;
+  lib: z.ZodString;
+}, z.core.$strip>;
+export declare const configSchema: z.ZodObject<{
+  framework: z.ZodEnum<{
+    react: "react";
+    vue: "vue";
+  }>;
+  css: z.ZodString;
+  registry: z.ZodString;
+  paths: z.ZodObject<{
+    ui: z.ZodString;
+    lib: z.ZodString;
+  }, z.core.$strip>;
+  aliases: z.ZodObject<{
+    ui: z.ZodString;
+    lib: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type CssValue = string | {
+  [selector: string]: CssValue;
+};
+type CssBlock = z.infer<typeof cssBlockSchema>;
+type Framework = z.infer<typeof frameworkSchema>;
+type ItemType = z.infer<typeof itemTypeSchema>;
+type RegistryFile = z.infer<typeof registryFileSchema>;
+type RegistryItem = z.infer<typeof registryItemSchema>;
+type RegistryIndex = z.infer<typeof registryIndexSchema>;
+type RegistryIndexEntry = z.infer<typeof registryIndexEntrySchema>;
+type Paths = z.infer<typeof pathsSchema>;
+type Aliases = Paths;
+type Config = z.infer<typeof configSchema>;
+export declare class ValidationError extends Error {
+  readonly source: string;
+  readonly issues: readonly z.core.$ZodIssue[];
+  constructor(source: string, issues: readonly z.core.$ZodIssue[]);
+}
+export declare function validate<T>(schema: z.ZodType<T>, source: string, value: unknown): T;
+export declare function parseJson(source: string, text: string): unknown;
+export declare const jsonSchemas: () => {
+  "registry.json": z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    name: z.ZodString;
+    homepage: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      type: z.ZodEnum<{
+        "registry:ui": "registry:ui";
+        "registry:lib": "registry:lib";
+        "registry:theme": "registry:theme";
+      }>;
+      title: z.ZodOptional<z.ZodString>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  "registry-item.json": z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+      "registry:ui": "registry:ui";
+      "registry:lib": "registry:lib";
+      "registry:theme": "registry:theme";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    css: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<CssValue, unknown, z.core.$ZodTypeInternals<CssValue, unknown>>>>;
+    docs: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      type: z.ZodEnum<{
+        "registry:ui": "registry:ui";
+        "registry:lib": "registry:lib";
+        "registry:theme": "registry:theme";
+      }>;
+      content: z.ZodString;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+};
+//#endregion
+//#region src/config.d.ts
+export declare const CONFIG_FILE = "75neoui.json";
+export declare const DEFAULT_REGISTRY = "https://75neo-ui.pages.dev/r";
+export declare const DEFAULT_ALIASES: Aliases;
+export declare class ConfigError extends Error {
+  constructor(message: string);
+}
+export declare const configPath: (cwd: string) => string;
+export declare function readConfig(cwd: string): Promise<Config>;
+export declare function writeConfig(cwd: string, config: Config): Promise<void>;
+export declare function detectFramework(cwd: string): Promise<Framework | null>;
+export declare function detectCssEntry(cwd: string): Promise<string | null>;
+export declare const detectPaths: (cwd: string) => Paths;
+//#endregion
+//#region src/css.d.ts
+export declare function serialize(css: CssBlock): string;
+export declare function withImport(source: string, specifier: string): string;
+export declare function withTheme(source: string, css: CssBlock, marker: string): string;
+//#endregion
+//#region src/install.d.ts
+export declare class InstallError extends Error {
+  constructor(message: string);
+}
+export declare function destinationFor(file: Pick<RegistryFile, "path">, config: Config): string;
+export declare const rewriteImports: (content: string, config: Config) => string;
+interface WriteOptions {
+  readonly cwd: string;
+  readonly overwrite: boolean;
+}
+interface WriteResult {
+  readonly written: string[];
+  readonly skipped: string[];
+}
+export declare function writeFiles(items: readonly RegistryItem[], config: Config, options: WriteOptions): Promise<WriteResult>;
+//#endregion
+//#region src/pm.d.ts
+export declare const PACKAGE_MANAGERS: readonly ["npm", "pnpm", "yarn", "bun"];
+type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+export declare function detectPackageManager(cwd: string): PackageManager;
+interface InstallOptions {
+  readonly cwd: string;
+  readonly manager: PackageManager;
+  readonly dev?: boolean;
+}
+export declare function install(packages: readonly string[], options: InstallOptions): Promise<void>;
+//#endregion
+//#region src/registry.d.ts
+export declare class RegistryError extends Error {
+  constructor(message: string);
+}
+export declare const stripNamespace: (name: string) => string;
+export declare function fetchIndex(registry: string, framework: Framework): Promise<RegistryIndex>;
+export declare function fetchItem(registry: string, framework: Framework, name: string): Promise<RegistryItem>;
+export declare function resolveItems(registry: string, framework: Framework, names: readonly string[]): Promise<RegistryItem[]>;
+export declare const collectDependencies: (items: readonly RegistryItem[]) => string[];
+//#endregion
+export type { Aliases, Config, CssBlock, CssValue, Framework, InstallOptions, ItemType, PackageManager, Paths, RegistryFile, RegistryIndex, RegistryIndexEntry, RegistryItem, WriteOptions, WriteResult };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { A as configSchema, B as registryItemSchema, C as detectFramework, D as FRAMEWORKS, E as writeConfig, F as parseJson, I as registryFileEntrySchema, L as registryFileSchema, M as frameworkSchema, N as itemTypeSchema, O as ITEM_TYPES, P as jsonSchemas, R as registryIndexEntrySchema, S as detectCssEntry, T as readConfig, V as validate, _ as CONFIG_FILE, a as resolveItems, b as DEFAULT_REGISTRY, c as detectPackageManager, d as destinationFor, f as rewriteImports, g as withTheme, h as withImport, i as fetchItem, j as cssBlockSchema, k as ValidationError, l as install, m as serialize, n as collectDependencies, o as stripNamespace, p as writeFiles, r as fetchIndex, s as PACKAGE_MANAGERS, t as RegistryError, u as InstallError, v as ConfigError, w as detectPaths, x as configPath, y as DEFAULT_ALIASES, z as registryIndexSchema } from "./registry-C1lAzYLJ.mjs";
+export { CONFIG_FILE, ConfigError, DEFAULT_ALIASES, DEFAULT_REGISTRY, FRAMEWORKS, ITEM_TYPES, InstallError, PACKAGE_MANAGERS, RegistryError, ValidationError, collectDependencies, configPath, configSchema, cssBlockSchema, destinationFor, detectCssEntry, detectFramework, detectPackageManager, detectPaths, fetchIndex, fetchItem, frameworkSchema, install, itemTypeSchema, jsonSchemas, parseJson, readConfig, registryFileEntrySchema, registryFileSchema, registryIndexEntrySchema, registryIndexSchema, registryItemSchema, resolveItems, rewriteImports, serialize, stripNamespace, validate, withImport, withTheme, writeConfig, writeFiles };

package/dist/registry-C1lAzYLJ.mjs

@@ -0,0 +1,335 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+//#region src/schema.ts
+const FRAMEWORKS = ["react", "vue"];
+const ITEM_TYPES = [
+	"registry:ui",
+	"registry:lib",
+	"registry:theme"
+];
+const frameworkSchema = z.enum(FRAMEWORKS);
+const itemTypeSchema = z.enum(ITEM_TYPES);
+const cssValueSchema = z.lazy(() => z.union([z.string(), z.record(z.string(), cssValueSchema)]));
+const cssBlockSchema = z.record(z.string(), cssValueSchema);
+const registryFilePathSchema = z.string().regex(/^registry\/(?:(?:react|vue)\/ui\/[^/]+|shared\/lib)\/[^/]+$/, { message: "must be registry/<framework>/ui/<item>/<file> or registry/shared/lib/<file>, so the installer knows where to put it" });
+const registryFileSchema = z.object({
+	path: registryFilePathSchema,
+	type: itemTypeSchema,
+	content: z.string()
+});
+const registryFileEntrySchema = registryFileSchema.omit({ content: true });
+const registryItemSchema = z.object({
+	name: z.string().min(1),
+	type: itemTypeSchema,
+	title: z.string().optional(),
+	description: z.string().optional(),
+	dependencies: z.array(z.string()).optional(),
+	registryDependencies: z.array(z.string()).optional(),
+	css: cssBlockSchema.optional(),
+	docs: z.string().optional(),
+	files: z.array(registryFileSchema).optional()
+}).refine((item) => item.type === "registry:theme" || (item.files?.length ?? 0) > 0, {
+	message: "only a registry:theme item may ship without files",
+	path: ["files"]
+}).refine((item) => item.type !== "registry:ui" || item.css === void 0, {
+	message: "component CSS belongs in @75neo/ui, not in a registry item",
+	path: ["css"]
+});
+const registryIndexEntrySchema = z.object({
+	name: z.string().min(1),
+	type: itemTypeSchema,
+	title: z.string().optional(),
+	description: z.string().optional()
+});
+const registryIndexSchema = z.object({
+	name: z.string().min(1),
+	homepage: z.string().optional(),
+	items: z.array(registryIndexEntrySchema)
+});
+const pathsSchema = z.object({
+	ui: z.string().min(1),
+	lib: z.string().min(1)
+});
+const configSchema = z.object({
+	framework: frameworkSchema,
+	css: z.string().min(1),
+	registry: z.string().min(1),
+	paths: pathsSchema,
+	aliases: pathsSchema
+});
+var ValidationError = class extends Error {
+	source;
+	issues;
+	constructor(source, issues) {
+		const detail = issues.map((issue) => {
+			const location = issue.path.map(String).join(".");
+			return location === "" ? issue.message : `${location}: ${issue.message}`;
+		}).join("\n  ");
+		super(`${source} is not valid:\n  ${detail}`);
+		this.source = source;
+		this.issues = issues;
+		this.name = "ValidationError";
+	}
+};
+function validate(schema, source, value) {
+	const result = schema.safeParse(value);
+	if (!result.success) throw new ValidationError(source, result.error.issues);
+	return result.data;
+}
+function parseJson(source, text) {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new Error(`${source} is not valid JSON: ${error.message}`);
+	}
+}
+const jsonSchemas = () => ({
+	"registry.json": z.toJSONSchema(registryIndexSchema, { io: "input" }),
+	"registry-item.json": z.toJSONSchema(registryItemSchema, { io: "input" })
+});
+//#endregion
+//#region src/config.ts
+const CONFIG_FILE = "75neoui.json";
+const DEFAULT_REGISTRY = "https://75neo-ui.pages.dev/r";
+const DEFAULT_ALIASES = {
+	ui: "@/components/ui",
+	lib: "@/lib"
+};
+const SRC_PATHS = {
+	ui: "src/components/ui",
+	lib: "src/lib"
+};
+const ROOT_PATHS = {
+	ui: "components/ui",
+	lib: "lib"
+};
+const CSS_CANDIDATES = [
+	"src/styles/global.css",
+	"src/styles/globals.css",
+	"src/app.css",
+	"src/index.css",
+	"src/style.css",
+	"src/assets/css/main.css",
+	"app/globals.css",
+	"styles/globals.css"
+];
+var ConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ConfigError";
+	}
+};
+const configPath = (cwd) => path.join(cwd, CONFIG_FILE);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+async function readConfig(cwd) {
+	const file = configPath(cwd);
+	if (!existsSync(file)) throw new ConfigError(`No ${CONFIG_FILE} found in ${cwd}. Run \`75neoui init\` first.`);
+	const document = parseJson(CONFIG_FILE, await readFile(file, "utf8"));
+	const withDefaults = isObject(document) ? {
+		registry: DEFAULT_REGISTRY,
+		paths: SRC_PATHS,
+		aliases: DEFAULT_ALIASES,
+		...document
+	} : document;
+	return validate(configSchema, CONFIG_FILE, withDefaults);
+}
+async function writeConfig(cwd, config) {
+	await writeFile(configPath(cwd), `${JSON.stringify(config, null, 2)}\n`);
+}
+async function detectFramework(cwd) {
+	const file = path.join(cwd, "package.json");
+	if (!existsSync(file)) return null;
+	let document;
+	try {
+		document = JSON.parse(await readFile(file, "utf8"));
+	} catch {
+		return null;
+	}
+	if (!isObject(document)) return null;
+	const dependencies = isObject(document["dependencies"]) ? document["dependencies"] : {};
+	const devDependencies = isObject(document["devDependencies"]) ? document["devDependencies"] : {};
+	const all = {
+		...dependencies,
+		...devDependencies
+	};
+	if ("vue" in all) return "vue";
+	if ("react" in all) return "react";
+	return null;
+}
+async function detectCssEntry(cwd) {
+	for (const candidate of CSS_CANDIDATES) {
+		const file = path.join(cwd, candidate);
+		if (!existsSync(file)) continue;
+		const source = await readFile(file, "utf8");
+		if (source.includes("@import \"tailwindcss\"") || source.includes("@import 'tailwindcss'")) return candidate;
+	}
+	return null;
+}
+const detectPaths = (cwd) => existsSync(path.join(cwd, "src")) ? SRC_PATHS : ROOT_PATHS;
+//#endregion
+//#region src/css.ts
+function rule(selector, body, indent) {
+	const lines = Object.entries(body).flatMap(([key, value]) => typeof value === "string" ? [`${indent}  ${key}: ${value};`] : rule(key, value, `${indent}  `));
+	return [
+		`${indent}${selector} {`,
+		...lines,
+		`${indent}}`
+	];
+}
+function serialize(css) {
+	const sections = Object.entries(css).map(([selector, body]) => {
+		if (typeof body === "string") return `${selector}: ${body};`;
+		return Object.keys(body).length === 0 ? `${selector};` : rule(selector, body, "").join("\n");
+	});
+	return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
+}
+function withImport(source, specifier) {
+	if (source.includes(`"${specifier}"`) || source.includes(`'${specifier}'`)) return source;
+	const lines = source.split("\n");
+	const last = lines.reduce((index, line, position) => line.trimStart().startsWith("@import ") ? position : index, -1);
+	if (last === -1) return `@import "${specifier}";\n\n${source}`;
+	lines.splice(last + 1, 0, `@import "${specifier}";`);
+	return lines.join("\n");
+}
+function withTheme(source, css, marker) {
+	if (source.includes(marker)) return source;
+	return `${source.replace(/\s*$/, "\n")}\n${marker}\n${serialize(css)}`;
+}
+//#endregion
+//#region src/install.ts
+const UI_PREFIX = /^registry\/(?:react|vue)\/ui\//;
+const LIB_PREFIX = /^registry\/shared\/lib\//;
+var InstallError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InstallError";
+	}
+};
+function destinationFor(file, config) {
+	if (UI_PREFIX.test(file.path)) return path.join(config.paths.ui, file.path.replace(UI_PREFIX, ""));
+	if (LIB_PREFIX.test(file.path)) return path.join(config.paths.lib, file.path.replace(LIB_PREFIX, ""));
+	throw new InstallError(`Cannot place ${file.path}; it is outside the known registry layout.`);
+}
+const rewriteImports = (content, config) => content.replaceAll("@/registry/react/ui/", `${config.aliases.ui}/`).replaceAll("@/registry/vue/ui/", `${config.aliases.ui}/`).replaceAll("@/registry/shared/lib/", `${config.aliases.lib}/`);
+async function writeFiles(items, config, options) {
+	const written = [];
+	const skipped = [];
+	for (const item of items) for (const file of item.files ?? []) {
+		const relative = destinationFor(file, config);
+		const absolute = path.join(options.cwd, relative);
+		if (existsSync(absolute) && !options.overwrite) {
+			skipped.push(relative);
+			continue;
+		}
+		await mkdir(path.dirname(absolute), { recursive: true });
+		await writeFile(absolute, rewriteImports(file.content, config));
+		written.push(relative);
+	}
+	return {
+		written,
+		skipped
+	};
+}
+//#endregion
+//#region src/pm.ts
+const PACKAGE_MANAGERS = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+];
+const LOCKFILES = [
+	["pnpm-lock.yaml", "pnpm"],
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"],
+	["yarn.lock", "yarn"],
+	["package-lock.json", "npm"]
+];
+const ADD = {
+	npm: ["install"],
+	pnpm: ["add"],
+	yarn: ["add"],
+	bun: ["add"]
+};
+function detectPackageManager(cwd) {
+	let directory = path.resolve(cwd);
+	for (;;) {
+		for (const [lockfile, manager] of LOCKFILES) if (existsSync(path.join(directory, lockfile))) return manager;
+		const parent = path.dirname(directory);
+		if (parent === directory) return "npm";
+		directory = parent;
+	}
+}
+function install(packages, options) {
+	if (packages.length === 0) return Promise.resolve();
+	const args = [
+		...ADD[options.manager],
+		...options.dev === true ? ["-D"] : [],
+		...packages
+	];
+	return new Promise((resolve, reject) => {
+		const child = spawn(options.manager, args, {
+			cwd: options.cwd,
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`${options.manager} ${args.join(" ")} exited with code ${String(code)}.`));
+		});
+	});
+}
+//#endregion
+//#region src/registry.ts
+const NAMESPACE = /^@75neo\//;
+var RegistryError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RegistryError";
+	}
+};
+const stripNamespace = (name) => name.replace(NAMESPACE, "");
+const isRemote = (registry) => /^https?:\/\//.test(registry);
+async function read(registry, framework, file) {
+	if (isRemote(registry)) {
+		const url = `${registry.replace(/\/$/, "")}/${framework}/${file}`;
+		const response = await fetch(url);
+		if (!response.ok) throw new RegistryError(`${url} returned ${String(response.status)} ${response.statusText}.`);
+		return [url, parseJson(url, await response.text())];
+	}
+	const location = path.resolve(registry, framework, file);
+	if (!existsSync(location)) throw new RegistryError(`${location} does not exist.`);
+	return [location, parseJson(location, await readFile(location, "utf8"))];
+}
+async function fetchIndex(registry, framework) {
+	const [source, document] = await read(registry, framework, "registry.json");
+	return validate(registryIndexSchema, source, document);
+}
+async function fetchItem(registry, framework, name) {
+	const [source, document] = await read(registry, framework, `${stripNamespace(name)}.json`);
+	return validate(registryItemSchema, source, document);
+}
+async function resolveItems(registry, framework, names) {
+	const resolved = /* @__PURE__ */ new Map();
+	const queue = names.map(stripNamespace);
+	while (queue.length > 0) {
+		const name = queue.shift();
+		if (name === void 0 || resolved.has(name)) continue;
+		let item;
+		try {
+			item = await fetchItem(registry, framework, name);
+		} catch (error) {
+			throw new RegistryError(`Could not resolve "${name}". ${error.message}`);
+		}
+		resolved.set(name, item);
+		for (const dependency of item.registryDependencies ?? []) queue.push(stripNamespace(dependency));
+	}
+	return [...resolved.values()];
+}
+const collectDependencies = (items) => [...new Set(items.flatMap((item) => [...item.dependencies ?? []]))].sort();
+//#endregion
+export { configSchema as A, registryItemSchema as B, detectFramework as C, FRAMEWORKS as D, writeConfig as E, parseJson as F, registryFileEntrySchema as I, registryFileSchema as L, frameworkSchema as M, itemTypeSchema as N, ITEM_TYPES as O, jsonSchemas as P, registryIndexEntrySchema as R, detectCssEntry as S, readConfig as T, validate as V, CONFIG_FILE as _, resolveItems as a, DEFAULT_REGISTRY as b, detectPackageManager as c, destinationFor as d, rewriteImports as f, withTheme as g, withImport as h, fetchItem as i, cssBlockSchema as j, ValidationError as k, install as l, serialize as m, collectDependencies as n, stripNamespace as o, writeFiles as p, fetchIndex as r, PACKAGE_MANAGERS as s, RegistryError as t, InstallError as u, ConfigError as v, detectPaths as w, configPath as x, DEFAULT_ALIASES as y, registryIndexSchema as z };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@75neo/ui",
+  "version": "1.0.0",
+  "description": "The 75NeoUI installer and animation stylesheet",
+  "keywords": [
+    "75neoui",
+    "react",
+    "registry",
+    "tailwindcss",
+    "vue"
+  ],
+  "homepage": "https://75neo-ui.pages.dev",
+  "license": "MIT",
+  "author": "Vo Quang Chien <2giosangmitom@gmail.com>",
+  "contributors": [
+    "Vo Van Duy <nstcrystal@gmail.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/75Neo/ui.git",
+    "directory": "packages/ui"
+  },
+  "bin": {
+    "75neoui": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "animations.css"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./animations.css": "./animations.css",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "yargs": "^18.1.0",
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "@types/yargs": "^17.0.35",
+    "tsdown": "^0.23.0",
+    "typescript": "~6.0.3",
+    "vitest": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc -p tsconfig.test.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}