@sidekick-coder/zenith-kit 0.0.1

package/dist/server/index.d.mts

@@ -0,0 +1,72 @@
+import { ChildProcess } from "node:child_process";
+
+//#region src/server/services/PluginIpcClient.d.ts
+type IpcMessage<T = any> = {
+  id: string;
+  event: string;
+  data: T;
+};
+type IpcListener$1<T = any> = (data: T) => void;
+declare class PluginIpcClient {
+  private listeners;
+  private pending;
+  constructor();
+  on<T = any>(event: string, callback: IpcListener$1<T>): void;
+  off<T = any>(event: string, callback: IpcListener$1<T>): void;
+  emit<T = any>(event: string, data?: T): string;
+  emitAsync<TData = any, TReply = any>(event: string, data?: TData): Promise<TReply>;
+}
+//#endregion
+//#region src/server/services/PluginIpcHost.d.ts
+type IpcListener<T = any> = (data: T) => void;
+declare class PluginIpcHost {
+  private readonly child;
+  private listeners;
+  private pending;
+  constructor(child: ChildProcess);
+  on<T = any>(event: string, callback: IpcListener<T>): void;
+  off<T = any>(event: string, callback: IpcListener<T>): void;
+  emit<T = any>(event: string, data?: T): string;
+  emitAsync<TData = any, TReply = any>(event: string, data?: TData): Promise<TReply>;
+}
+//#endregion
+//#region src/server/services/PluginRouter.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface RouteDefinition {
+  method: HttpMethod;
+  path: string;
+}
+interface RouteRequest {
+  requestId: string;
+  method: HttpMethod;
+  path: string;
+  body?: any;
+  headers?: Record<string, string>;
+  query?: Record<string, string>;
+  params?: Record<string, string>;
+}
+interface RouteResponsePayload {
+  requestId: string;
+  status: number;
+  body?: any;
+  headers?: Record<string, string>;
+}
+interface RouteReply {
+  status(code: number): RouteReply;
+  send(body?: any): void;
+}
+type RouteHandler = (req: RouteRequest, reply: RouteReply) => void | Promise<void>;
+declare class PluginRouter {
+  private readonly client;
+  private routes;
+  constructor(client: PluginIpcClient);
+  private dispatch;
+  private register;
+  get(path: string, handler: RouteHandler): void;
+  post(path: string, handler: RouteHandler): void;
+  put(path: string, handler: RouteHandler): void;
+  patch(path: string, handler: RouteHandler): void;
+  delete(path: string, handler: RouteHandler): void;
+}
+//#endregion
+export { HttpMethod, IpcMessage, PluginIpcClient, PluginIpcHost, PluginRouter, RouteDefinition, RouteHandler, RouteReply, RouteRequest, RouteResponsePayload };

package/dist/server/index.mjs

@@ -0,0 +1,185 @@
+//#region src/shared/utils/createId.ts
+function uuid() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	if (typeof self !== "undefined" && self.crypto && self.crypto.randomUUID) return self.crypto.randomUUID();
+	if (typeof window !== "undefined" && window.crypto && window.crypto.randomUUID) return window.crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+function createId(prefix = "") {
+	return prefix + uuid();
+}
+//#endregion
+//#region src/server/services/PluginIpcClient.ts
+var PluginIpcClient = class {
+	listeners = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	constructor() {
+		process.on("message", (message) => {
+			if (this.pending.has(message.id)) {
+				this.pending.get(message.id)(message.data);
+				this.pending.delete(message.id);
+			}
+			const handlers = this.listeners.get(message.event);
+			if (!handlers) return;
+			for (const handler of handlers) handler(message.data);
+		});
+	}
+	on(event, callback) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(callback);
+	}
+	off(event, callback) {
+		this.listeners.get(event)?.delete(callback);
+	}
+	emit(event, data) {
+		if (!process.send) throw new Error("PluginIpcClient.emit: process.send is not available — process was not spawned with IPC channel");
+		const id = createId();
+		const message = {
+			id,
+			event,
+			data
+		};
+		process.send(message);
+		return id;
+	}
+	emitAsync(event, data) {
+		return new Promise((resolve) => {
+			const id = this.emit(event, data);
+			this.pending.set(id, resolve);
+		});
+	}
+};
+//#endregion
+//#region src/server/services/PluginIpcHost.ts
+var PluginIpcHost = class {
+	listeners = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	constructor(child) {
+		this.child = child;
+		this.child.on("message", (message) => {
+			if (this.pending.has(message.id)) {
+				this.pending.get(message.id)(message.data);
+				this.pending.delete(message.id);
+			}
+			const handlers = this.listeners.get(message.event);
+			if (!handlers) return;
+			for (const handler of handlers) handler(message.data);
+		});
+	}
+	on(event, callback) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(callback);
+	}
+	off(event, callback) {
+		this.listeners.get(event)?.delete(callback);
+	}
+	emit(event, data) {
+		if (!this.child.send) throw new Error("PluginIpcHost.emit: child process was not spawned with an IPC channel");
+		const id = createId();
+		const message = {
+			id,
+			event,
+			data
+		};
+		this.child.send(message);
+		return id;
+	}
+	emitAsync(event, data) {
+		return new Promise((resolve) => {
+			const id = this.emit(event, data);
+			this.pending.set(id, resolve);
+		});
+	}
+};
+//#endregion
+//#region src/server/services/PluginRouter.ts
+function buildPattern(path) {
+	const paramNames = [];
+	const regexStr = path.replace(/:[a-zA-Z_][a-zA-Z0-9_]*/g, (match) => {
+		paramNames.push(match.slice(1));
+		return "([^/]+)";
+	}).replace(/\//g, "\\/");
+	return {
+		pattern: new RegExp(`^${regexStr}$`),
+		paramNames
+	};
+}
+var PluginRouter = class {
+	routes = [];
+	constructor(client) {
+		this.client = client;
+		this.client.on("router:request", (req) => this.dispatch(req));
+	}
+	async dispatch(req) {
+		for (const route of this.routes) {
+			if (route.method !== req.method) continue;
+			const match = route.pattern.exec(req.path);
+			if (!match) continue;
+			const params = {};
+			route.paramNames.forEach((name, i) => {
+				params[name] = match[i + 1];
+			});
+			let statusCode = 200;
+			const headers = {};
+			const reply = {
+				status(code) {
+					statusCode = code;
+					return this;
+				},
+				send: (body) => {
+					const response = {
+						requestId: req.requestId,
+						status: statusCode,
+						body,
+						headers
+					};
+					this.client.emit("router:response", response);
+				}
+			};
+			await route.handler({
+				...req,
+				params
+			}, reply);
+			return;
+		}
+		this.client.emit("router:response", {
+			requestId: req.requestId,
+			status: 404,
+			body: { message: "Not Found" }
+		});
+	}
+	register(method, path, handler) {
+		const { pattern, paramNames } = buildPattern(path);
+		this.routes.push({
+			method,
+			path,
+			handler,
+			pattern,
+			paramNames
+		});
+		this.client.emit("router:register", {
+			method,
+			path
+		});
+	}
+	get(path, handler) {
+		this.register("GET", path, handler);
+	}
+	post(path, handler) {
+		this.register("POST", path, handler);
+	}
+	put(path, handler) {
+		this.register("PUT", path, handler);
+	}
+	patch(path, handler) {
+		this.register("PATCH", path, handler);
+	}
+	delete(path, handler) {
+		this.register("DELETE", path, handler);
+	}
+};
+//#endregion
+export { PluginIpcClient, PluginIpcHost, PluginRouter };

package/dist/shared/index.d.mts

@@ -0,0 +1,107 @@
+import * as v from "valibot";
+
+//#region src/shared/services/LoggerService.d.ts
+declare class LoggerService {
+  info(message: string, meta?: any): void;
+  debug(message: string, meta?: any): void;
+  warn(message: string, meta?: any): void;
+  error(message: string, meta?: any): void;
+  child(options: any): LoggerService;
+}
+//#endregion
+//#region src/shared/services/EmmitterService.d.ts
+interface EmmitterServiceOptions {
+  debug?: boolean;
+  logger?: LoggerService;
+}
+//#endregion
+//#region src/shared/utils/typing.d.ts
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type PublicData<T> = { [K in keyof T as T[K] extends Function ? never : K]: T[K] };
+//#endregion
+//#region src/shared/utils/compose.d.ts
+type AnyClass = new (...args: any[]) => any;
+type Constructor<T = {}> = new (...args: any[]) => T;
+type Mixin<T> = (base: Constructor) => Constructor<T>;
+/**
+ * Composes multiple mixins into a single class that can be extended.
+ * Allows for multiple inheritance-like behavior by applying mixins sequentially.
+ *
+ * @param mixins - Array of mixin functions to compose
+ * @returns A class constructor that includes all mixin functionality
+ *
+ * @example
+ * ```typescript
+ * class User extends compose(Timestamp, SoftDelete) {
+ *   constructor(public name: string) {
+ *     super()
+ *   }
+ * }
+ * ```
+ */
+declare function compose<M extends Array<(base: Constructor<any>) => Constructor<any>>>(...mixins: M): UnionToIntersection<ReturnType<M[number]>>;
+/**
+ * Alternative compose function that starts with a base class
+ *
+ * @param baseClass - The base class to start with
+ * @param mixins - Array of mixin functions to apply
+ * @returns A class constructor that extends the base class with all mixin functionality
+ *
+ * @example
+ * ```typescript
+ * class User extends composeWith(BaseEntity, Timestamp, SoftDelete) {
+ *   constructor(public name: string) {
+ *     super()
+ *   }
+ * }
+ * ```
+ */
+declare function composeWith<TBase extends Constructor, M extends Array<(base: Constructor) => Constructor<any>>>(baseClass: TBase, ...mixins: M): TBase & UnionToIntersection<ReturnType<M[number]>>;
+declare function mixin<TBase extends Constructor>(Source: TBase): <TTarget extends Constructor>(Target: TTarget) => TTarget & TBase;
+//#endregion
+//#region src/shared/services/ValidatorService.d.ts
+type Valibot = typeof v;
+type ValibotSchema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>;
+type ValibotSchemaAsync = v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>;
+interface ValidatorCallback<T extends ValibotSchema> {
+  (_v: typeof v): T;
+}
+type ValidatorCallbackAsync<T extends ValibotSchemaAsync> = {
+  (_v: typeof v): T;
+};
+type ValidatorResult<T extends v.ObjectEntries> = v.InferOutput<v.ObjectSchema<T, undefined>>;
+type ValidatePayload<T extends ValibotSchema = ValibotSchema> = ValidatorCallback<T> | T;
+type ValidateResult<T extends ValidatePayload> = T extends ValibotSchema ? v.InferOutput<T> : T extends ValidatorCallback<infer U> ? v.InferOutput<U> : unknown;
+declare class ValidatorService {
+  create<T extends ValibotSchema>(cb: ValidatorCallback<T>): T;
+  validate<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): v.InferOutput<T>;
+  validateAsync<T extends ValibotSchemaAsync>(payload: any, cb: ValidatorCallbackAsync<T> | T): Promise<v.InferOutput<T>>;
+  isValid<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): boolean;
+}
+//#endregion
+//#region src/shared/utils/createId.d.ts
+declare function createId(prefix?: string): string;
+//#endregion
+//#region src/shared/utils/flatten.d.ts
+declare function flatten(obj: any, prefix?: string, res?: any): Record<string, any>;
+declare function unflatten(obj: any): Record<string, any>;
+//#endregion
+//#region src/shared/utils/formatBytes.d.ts
+declare function formatBytes(bytes: number, decimals?: number): string;
+//#endregion
+//#region src/shared/utils/tryCatch.d.ts
+interface Tryer {
+  (...args: any[]): any;
+}
+interface TryerAsync {
+  (...args: any[]): Promise<any> | any;
+}
+type TryCatchResult<T extends Tryer> = [null, ReturnType<T>] | [Error, null];
+type TryCatchAsyncResult<T extends TryerAsync> = [null, Awaited<ReturnType<T>>] | [Error, null];
+declare function tryCatch<T extends TryerAsync>(tryer: T): Promise<TryCatchAsyncResult<T>>;
+declare namespace tryCatch {
+  var sync: <T extends Tryer>(tryer: T) => TryCatchResult<T>;
+}
+//#endregion
+export { AnyClass, Constructor, EmmitterServiceOptions, Mixin, PartialBy, PublicData, UnionToIntersection, Valibot, ValibotSchema, ValibotSchemaAsync, ValidatePayload, ValidateResult, ValidatorCallback, ValidatorCallbackAsync, ValidatorResult, ValidatorService, compose, composeWith, createId, flatten, formatBytes, mixin, tryCatch, unflatten };

package/dist/shared/index.mjs

@@ -0,0 +1,187 @@
+import "lodash-es";
+import * as v from "valibot";
+//#region src/shared/utils/compose.ts
+/**
+* Composes multiple mixins into a single class that can be extended.
+* Allows for multiple inheritance-like behavior by applying mixins sequentially.
+* 
+* @param mixins - Array of mixin functions to compose
+* @returns A class constructor that includes all mixin functionality
+* 
+* @example
+* ```typescript
+* class User extends compose(Timestamp, SoftDelete) {
+*   constructor(public name: string) {
+*     super()
+*   }
+* }
+* ```
+*/
+function compose(...mixins) {
+	return mixins.reduce((base, mixin) => mixin(base), class {});
+}
+/**
+* Alternative compose function that starts with a base class
+* 
+* @param baseClass - The base class to start with
+* @param mixins - Array of mixin functions to apply
+* @returns A class constructor that extends the base class with all mixin functionality
+* 
+* @example
+* ```typescript
+* class User extends composeWith(BaseEntity, Timestamp, SoftDelete) {
+*   constructor(public name: string) {
+*     super()
+*   }
+* }
+* ```
+*/
+function composeWith(baseClass, ...mixins) {
+	return mixins.reduce((base, mixin) => mixin(base), baseClass);
+}
+function mixin(Source) {
+	return function(Target) {
+		class Mixed extends Target {
+			constructor(...args) {
+				super(...args);
+				const source = new Source(...args);
+				Object.assign(this, source);
+			}
+		}
+		for (const key of Reflect.ownKeys(Source.prototype)) if (key !== "constructor") Object.defineProperty(Mixed.prototype, key, Object.getOwnPropertyDescriptor(Source.prototype, key));
+		return Mixed;
+	};
+}
+//#endregion
+//#region src/shared/utils/formatBytes.ts
+function formatBytes(bytes, decimals = 2) {
+	if (bytes === 0) return "0 Bytes";
+	const k = 1024;
+	const dm = decimals < 0 ? 0 : decimals;
+	const sizes = [
+		"Bytes",
+		"KB",
+		"MB",
+		"GB",
+		"TB",
+		"PB"
+	];
+	const i = Math.floor(Math.log(bytes) / Math.log(k));
+	return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+}
+//#endregion
+//#region src/shared/utils/flatten.ts
+function flatten(obj, prefix = "", res = {}) {
+	for (const [key, value] of Object.entries(obj)) {
+		const newKey = prefix ? `${prefix}.${key}` : key;
+		if (value && typeof value === "object" && !Array.isArray(value)) flatten(value, newKey, res);
+		else res[newKey] = value;
+	}
+	return res;
+}
+function unflatten(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const parts = key.split(".");
+		let current = result;
+		parts.forEach((part, i) => {
+			if (i === parts.length - 1) current[part] = value;
+			else {
+				if (!current[part] || typeof current[part] !== "object") current[part] = {};
+				current = current[part];
+			}
+		});
+	}
+	return result;
+}
+//#endregion
+//#region src/shared/utils/tryCatch.ts
+async function tryCatch(tryer) {
+	try {
+		return [null, await tryer()];
+	} catch (error) {
+		return [error, null];
+	}
+}
+tryCatch.sync = function(tryer) {
+	try {
+		return [null, tryer()];
+	} catch (error) {
+		return [error, null];
+	}
+};
+//#endregion
+//#region src/shared/utils/createId.ts
+function uuid() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	if (typeof self !== "undefined" && self.crypto && self.crypto.randomUUID) return self.crypto.randomUUID();
+	if (typeof window !== "undefined" && window.crypto && window.crypto.randomUUID) return window.crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+function createId(prefix = "") {
+	return prefix + uuid();
+}
+//#endregion
+//#region src/shared/exceptions/BaseException.ts
+var BaseException = class BaseException extends Error {
+	statusCode = 500;
+	constructor(message, statusCode = 500) {
+		super(message);
+		this.name = this.constructor.name;
+		this.statusCode = statusCode;
+	}
+	static fromError(error) {
+		return new BaseException(error.message, 500);
+	}
+};
+//#endregion
+//#region src/shared/services/ValidatorService.ts
+var ValidatorService = class {
+	create(cb) {
+		return cb(v);
+	}
+	validate(payload, cb) {
+		const schema = typeof cb === "function" ? cb(v) : cb;
+		const { output, issues, success } = v.safeParse(schema, payload);
+		if (!success) {
+			const flatten = v.flatten(issues);
+			const messages = [];
+			if (flatten.root) messages.push(...flatten.root);
+			if (flatten.nested) Object.entries(flatten.nested).forEach((entry) => {
+				const [key, value] = entry;
+				messages.push(...value.map((v) => `${key}: ${v}`));
+			});
+			const error = new BaseException(messages.length ? messages.join(", ") : "Validation failed", 422);
+			error.name = "ValidationError";
+			Object.assign(error, { messages });
+			throw error;
+		}
+		return output;
+	}
+	async validateAsync(payload, cb) {
+		const schema = typeof cb === "function" ? cb(v) : cb;
+		const { output, issues, success } = await v.safeParseAsync(schema, payload);
+		if (!success) {
+			const error = /* @__PURE__ */ new Error("Validation failed");
+			const flatten = v.flatten(issues);
+			const details = {
+				...flatten.root,
+				...flatten.nested
+			};
+			Object.assign(error, { details });
+			throw error;
+		}
+		return output;
+	}
+	isValid(payload, cb) {
+		const schema = typeof cb === "function" ? cb(v) : cb;
+		const { success } = v.safeParse(schema, payload);
+		return success;
+	}
+};
+new ValidatorService();
+//#endregion
+export { ValidatorService, compose, composeWith, createId, flatten, formatBytes, mixin, tryCatch, unflatten };

package/eslint.config.mts

@@ -0,0 +1,22 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import pluginVue from "eslint-plugin-vue";
+import json from "@eslint/json";
+import eslintConfigPrettier from "eslint-config-prettier/flat";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+    { files: ["**/*.{js,mjs,cjs,ts,mts,cts,vue}"], plugins: { js }, extends: ["js/recommended"], languageOptions: { globals: { ...globals.browser, ...globals.node } } },
+    tseslint.configs.recommended,
+    pluginVue.configs["flat/essential"],
+    { files: ["**/*.vue"], languageOptions: { parserOptions: { parser: tseslint.parser } } },
+    { files: ["**/*.json"], plugins: { json }, language: "json/json", extends: ["json/recommended"] },
+    { files: ["**/*.jsonc"], plugins: { json }, language: "json/jsonc", extends: ["json/recommended"] },
+    eslintConfigPrettier,
+    {
+        rules: {
+            '@typescript-eslint/no-explicit-any': 'off',
+        }
+    }
+]);

package/indexes.js

@@ -0,0 +1,37 @@
+import fg from 'fast-glob'
+import fs from 'fs'
+import path from 'path'
+
+// generate indexes for folders 
+
+function generate(options) {
+    const folders = options.folders
+    const filename = options.filename
+
+    let content = ''
+
+    for (const folder of folders) {
+        const files = fg.sync(`${folder}/**/*.ts`, { ignore: ['**/index.ts'] })
+
+        for (const file of files) {
+            const filePath = path.relative(path.dirname(filename), file)
+
+            content += `export * from './${filePath}'\n`
+        }
+    }
+
+    content = content.trim()
+
+    fs.writeFileSync(filename, content)
+}
+
+
+generate({
+    folders: ['src/shared/services', 'src/shared/utils'],
+    filename: 'src/shared/index.ts'
+})
+
+generate({
+    folders: ['src/server/services'],
+    filename: 'src/server/index.ts'
+})

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@sidekick-coder/zenith-kit",
+    "version": "0.0.1",
+    "license": "MIT",
+    "description": "A collection of utilities and tools for building language servers and related applications.",
+    "keywords": [],
+    "author": "Henrique Oliveira <henriqueoliwork@gmail.com>",
+    "homepage": "https://github.com/sidekick-coder/language-kit",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/sidekick-coder/language-kit.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "exports": {
+        "./shared": {
+            "import": "./dist/shared/index.mjs",
+            "require": "./dist/shared/index.js",
+            "types": "./dist/shared/index.d.mts"
+        },
+        "./server": {
+            "import": "./dist/server/index.mjs",
+            "require": "./dist/server/index.js",
+            "types": "./dist/server/index.d.mts"
+        }
+    },
+    "scripts": {
+        "generate:indexes": "node indexes.js",
+        "build": "node indexes.js && tsdown"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.39.4",
+        "@eslint/json": "^0.14.0",
+        "@types/lodash-es": "^4.17.12",
+        "@types/node": "^25.6.0",
+        "@vue/tsconfig": "^0.9.1",
+        "eslint": "^9.39.4",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-vue": "^10.8.0",
+        "globals": "^17.5.0",
+        "jiti": "^2.6.1",
+        "tsdown": "^0.21.9",
+        "typescript": "^6.0.3",
+        "typescript-eslint": "^8.58.2"
+    },
+    "dependencies": {
+        "fast-glob": "^3.3.3",
+        "lodash-es": "^4.18.1",
+        "valibot": "^1.3.1"
+    }
+}

package/tsconfig.client.json

@@ -0,0 +1,26 @@
+{
+    "extends": [
+        "@vue/tsconfig/tsconfig.dom.json"
+    ],
+    "compilerOptions": {
+        "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+        "strict": true,
+        "noUnusedLocals": false,
+        "noUnusedParameters": true,
+        "erasableSyntaxOnly": true,
+        "noFallthroughCasesInSwitch": true,
+        "noUncheckedSideEffectImports": true,
+        "strictPropertyInitialization": false,
+        "baseUrl": ".",
+        "lib": [
+            "es2023",
+            "dom",
+            "dom.iterable"
+        ]
+    },
+    "include": [
+        "client/**/**/*.ts",
+        "client/**/**/*.vue",
+        "shared/**/**/*.ts",
+    ]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "files": [],
+    "references": [
+        { "path": "./tsconfig.client.json" },
+        { "path": "./tsconfig.server.json" },
+        { "path": "./tsconfig.shared.json" }
+    ]
+}

package/tsconfig.server.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": [
+      "ES2023"
+    ],
+    "types": [
+      "node"
+    ],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "strictPropertyInitialization": false
+  },
+  "include": [
+    "src/server/**/*.ts",
+    "src/shared/**/*.ts"
+  ]
+}

package/tsconfig.shared.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": [
+      "ES2023"
+    ],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "strictPropertyInitialization": false
+  },
+  "include": [
+    "src/shared/**/*.ts",
+  ]
+}

package/tsdown.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig([
+    {
+        entry: 'src/shared/index.ts',
+        outDir: 'dist/shared',
+        tsconfig: 'tsconfig.shared.json',
+    },
+    {
+        entry: 'src/server/index.ts',
+        outDir: 'dist/server',
+        tsconfig: 'tsconfig.server.json',
+    }
+])