kerria 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025-present KazariEX
+
+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/index.cjs

@@ -0,0 +1,235 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createProcessor: () => createProcessor,
+  useCurrentContext: () => useCurrentContext,
+  useLoad: () => useLoad,
+  useSource: () => useSource
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/processor.ts
+var import_chokidar = __toESM(require("chokidar"), 1);
+var import_consola = __toESM(require("consola"), 1);
+var import_crypto_es = __toESM(require("crypto-es"), 1);
+var import_find_cache_dir = __toESM(require("find-cache-dir"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_pathe = require("pathe");
+var import_tinyglobby = require("tinyglobby");
+
+// src/utils.ts
+var isDev = process.env.NODE_ENV === "development";
+
+// src/core/processor.ts
+var currentContext = null;
+function useCurrentContext() {
+  return currentContext;
+}
+function createProcessor(sign, setup) {
+  const ctx = {
+    sign,
+    loadInfos: [],
+    sourceInfos: []
+  };
+  currentContext = ctx;
+  setup(ctx);
+  currentContext = null;
+  ctx.sourceInfos.sort((a, b) => {
+    return a.kind - b.kind;
+  });
+  const cacheDir = (0, import_find_cache_dir.default)({ name: "kerria" });
+  const cachePath = (0, import_pathe.join)(cacheDir, `${sign}.json`);
+  const caches = import_fs_extra.default.existsSync(cachePath) && import_fs_extra.default.readJsonSync(cachePath) || {};
+  async function build() {
+    for (const info of ctx.sourceInfos) {
+      const paths = await (0, import_tinyglobby.glob)(info.patterns, {
+        deep: info.deep ? Infinity : 2,
+        absolute: true
+      });
+      await Promise.all(
+        paths.map((path) => path.replaceAll("\\", "/")).filter(info.filter).sort((a, b) => a.localeCompare(b)).map((path) => parse(path, info))
+      );
+    }
+    outputLoads();
+    import_consola.default.success(`[${sign}] Build`);
+  }
+  async function watch() {
+    for (const info of ctx.sourceInfos) {
+      import_chokidar.default.watch(info.folders, {
+        depth: info.deep ? Infinity : 0,
+        ignoreInitial: true
+      }).on("all", async (event, filename) => {
+        const path = filename.replaceAll("\\", "/");
+        if (!path.endsWith(info.ext)) {
+          return false;
+        } else if (!info.filter(path)) {
+          return false;
+        } else if (event === "change" && !await parse(path, info)) {
+          return false;
+        } else if (event === "add" && !await add(path, info)) {
+          return false;
+        } else if (event === "unlink" && !unlink(path, info)) {
+          return false;
+        }
+        outputLoads();
+        import_consola.default.success(`[${sign}] ${event} "${path}"`);
+      });
+    }
+    for (const info of ctx.loadInfos) {
+      if (!info.src) {
+        continue;
+      }
+      import_chokidar.default.watch(info.src, {
+        ignoreInitial: true
+      }).on("change", async () => {
+        const newVal = await import_fs_extra.default.readJson(info.src);
+        info.value = info.onUpdate(newVal, info.value);
+        info.output();
+        import_consola.default.success(`[${sign}] Change "${info.src}"`);
+      });
+    }
+  }
+  async function parse(path, info) {
+    const stats = await import_fs_extra.default.stat(path);
+    const hash = import_crypto_es.default.MD5(stats.size.toString()).toString();
+    let cache = caches[path];
+    if (isDev && cache?.hash === hash) {
+      info.onCacheHit?.(cache);
+      return false;
+    }
+    cache = { hash };
+    const data = await info.parse(path, info);
+    if (data !== null) {
+      cache = {
+        ...cache,
+        ...data ?? {}
+      };
+      info.onCacheHit?.(cache);
+      caches[path] = cache;
+    } else {
+      unlink(path, info);
+    }
+    return true;
+  }
+  async function add(path, info) {
+    const cache = caches[path];
+    if (cache) {
+      return false;
+    }
+    return await parse(path, info);
+  }
+  function unlink(path, info) {
+    const cache = caches[path];
+    if (!cache) {
+      return false;
+    }
+    info.unlink?.(cache);
+    delete caches[path];
+    return true;
+  }
+  function outputLoads() {
+    import_fs_extra.default.outputJsonSync(cachePath, caches);
+    for (const info of ctx.loadInfos) {
+      info.output();
+    }
+  }
+  return {
+    build,
+    watch
+  };
+}
+
+// src/core/useLoad.ts
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_pathe2 = require("pathe");
+function useLoad(name, options) {
+  const ctx = useCurrentContext();
+  const src = options.src ? (0, import_pathe2.resolve)(options.src) : void 0;
+  const out = (0, import_pathe2.resolve)(options.out);
+  const {
+    defaultValue,
+    onUpdate,
+    beforeOutput
+  } = options;
+  const info = {
+    name,
+    src,
+    out,
+    value: src ? import_fs_extra2.default.readJsonSync(src) : defaultValue ?? {},
+    output() {
+      const data = beforeOutput?.(info.value) ?? info.value;
+      import_fs_extra2.default.outputJsonSync(info.out, data);
+    },
+    onUpdate
+  };
+  ctx.loadInfos.push(info);
+  onUpdate(info.value, void 0);
+  return info;
+}
+
+// src/core/useSource.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_pathe3 = require("pathe");
+function useSource(kind, options) {
+  const ctx = useCurrentContext();
+  const base = (0, import_pathe3.resolve)(options.base);
+  const dist = options.dist ? (0, import_pathe3.resolve)(options.dist) : void 0;
+  const folders = options.folders?.map((folder) => (0, import_pathe3.resolve)(base, folder)) ?? [base];
+  const patterns = folders.map((path) => (0, import_pathe3.resolve)(path, `**/*${options.ext}`));
+  const info = {
+    ...options,
+    kind,
+    base,
+    dist,
+    folders,
+    patterns,
+    deep: options.deep ?? true,
+    skip: options.skip ?? 0,
+    filter(path) {
+      const depth = path.split("/").length - folders[0].split("/").length;
+      return info.skip < depth;
+    },
+    async output(path, data) {
+      const outPath = path.replace(base, dist).replace(info.ext, ".json");
+      await import_fs_extra3.default.outputJson(outPath, data);
+    }
+  };
+  ctx.sourceInfos.push(info);
+  return info;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProcessor,
+  useCurrentContext,
+  useLoad,
+  useSource
+});

package/dist/index.d.cts

@@ -0,0 +1,48 @@
+interface LoadInfo extends Omit<UseLoadOptions, "defaultValue" | "beforeOutput"> {
+    name: string;
+    value: any;
+    output: () => void;
+}
+interface UseLoadOptions {
+    src?: string;
+    out: string;
+    defaultValue?: unknown;
+    onUpdate: (newVal: any, oldVal: any) => any;
+    beforeOutput?: (val: any) => any;
+}
+declare function useLoad(name: string, options: UseLoadOptions): LoadInfo;
+
+type MaybePromise<T> = T | Promise<T>;
+
+interface SourceInfo extends Omit<UseSourceOptions, "folders"> {
+    kind: number;
+    folders: string[];
+    patterns: string[];
+    filter: (path: string) => boolean;
+    output: (path: string, data: any) => Promise<void>;
+}
+interface UseSourceOptions<T = any> {
+    base: string;
+    dist?: string;
+    folders?: string[];
+    ext: string;
+    deep?: boolean;
+    skip?: number;
+    parse: (path: string, info: SourceInfo) => MaybePromise<T | null | void>;
+    unlink?: (cache: T) => void;
+    onCacheHit?: (cache: T) => void;
+}
+declare function useSource<C extends object>(kind: number, options: UseSourceOptions<C>): SourceInfo;
+
+interface ProcessorContext {
+    sign: string;
+    loadInfos: LoadInfo[];
+    sourceInfos: SourceInfo[];
+}
+declare function useCurrentContext(): ProcessorContext;
+declare function createProcessor(sign: string, setup: (ctx: ProcessorContext) => void): {
+    build: () => Promise<void>;
+    watch: () => Promise<void>;
+};
+
+export { type LoadInfo, type SourceInfo, type UseLoadOptions, createProcessor, useCurrentContext, useLoad, useSource };

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+interface LoadInfo extends Omit<UseLoadOptions, "defaultValue" | "beforeOutput"> {
+    name: string;
+    value: any;
+    output: () => void;
+}
+interface UseLoadOptions {
+    src?: string;
+    out: string;
+    defaultValue?: unknown;
+    onUpdate: (newVal: any, oldVal: any) => any;
+    beforeOutput?: (val: any) => any;
+}
+declare function useLoad(name: string, options: UseLoadOptions): LoadInfo;
+
+type MaybePromise<T> = T | Promise<T>;
+
+interface SourceInfo extends Omit<UseSourceOptions, "folders"> {
+    kind: number;
+    folders: string[];
+    patterns: string[];
+    filter: (path: string) => boolean;
+    output: (path: string, data: any) => Promise<void>;
+}
+interface UseSourceOptions<T = any> {
+    base: string;
+    dist?: string;
+    folders?: string[];
+    ext: string;
+    deep?: boolean;
+    skip?: number;
+    parse: (path: string, info: SourceInfo) => MaybePromise<T | null | void>;
+    unlink?: (cache: T) => void;
+    onCacheHit?: (cache: T) => void;
+}
+declare function useSource<C extends object>(kind: number, options: UseSourceOptions<C>): SourceInfo;
+
+interface ProcessorContext {
+    sign: string;
+    loadInfos: LoadInfo[];
+    sourceInfos: SourceInfo[];
+}
+declare function useCurrentContext(): ProcessorContext;
+declare function createProcessor(sign: string, setup: (ctx: ProcessorContext) => void): {
+    build: () => Promise<void>;
+    watch: () => Promise<void>;
+};
+
+export { type LoadInfo, type SourceInfo, type UseLoadOptions, createProcessor, useCurrentContext, useLoad, useSource };

package/dist/index.js

@@ -0,0 +1,195 @@
+// src/core/processor.ts
+import chokidar from "chokidar";
+import consola from "consola";
+import CryptoES from "crypto-es";
+import findCacheDir from "find-cache-dir";
+import fs from "fs-extra";
+import { join } from "pathe";
+import { glob } from "tinyglobby";
+
+// src/utils.ts
+var isDev = process.env.NODE_ENV === "development";
+
+// src/core/processor.ts
+var currentContext = null;
+function useCurrentContext() {
+  return currentContext;
+}
+function createProcessor(sign, setup) {
+  const ctx = {
+    sign,
+    loadInfos: [],
+    sourceInfos: []
+  };
+  currentContext = ctx;
+  setup(ctx);
+  currentContext = null;
+  ctx.sourceInfos.sort((a, b) => {
+    return a.kind - b.kind;
+  });
+  const cacheDir = findCacheDir({ name: "kerria" });
+  const cachePath = join(cacheDir, `${sign}.json`);
+  const caches = fs.existsSync(cachePath) && fs.readJsonSync(cachePath) || {};
+  async function build() {
+    for (const info of ctx.sourceInfos) {
+      const paths = await glob(info.patterns, {
+        deep: info.deep ? Infinity : 2,
+        absolute: true
+      });
+      await Promise.all(
+        paths.map((path) => path.replaceAll("\\", "/")).filter(info.filter).sort((a, b) => a.localeCompare(b)).map((path) => parse(path, info))
+      );
+    }
+    outputLoads();
+    consola.success(`[${sign}] Build`);
+  }
+  async function watch() {
+    for (const info of ctx.sourceInfos) {
+      chokidar.watch(info.folders, {
+        depth: info.deep ? Infinity : 0,
+        ignoreInitial: true
+      }).on("all", async (event, filename) => {
+        const path = filename.replaceAll("\\", "/");
+        if (!path.endsWith(info.ext)) {
+          return false;
+        } else if (!info.filter(path)) {
+          return false;
+        } else if (event === "change" && !await parse(path, info)) {
+          return false;
+        } else if (event === "add" && !await add(path, info)) {
+          return false;
+        } else if (event === "unlink" && !unlink(path, info)) {
+          return false;
+        }
+        outputLoads();
+        consola.success(`[${sign}] ${event} "${path}"`);
+      });
+    }
+    for (const info of ctx.loadInfos) {
+      if (!info.src) {
+        continue;
+      }
+      chokidar.watch(info.src, {
+        ignoreInitial: true
+      }).on("change", async () => {
+        const newVal = await fs.readJson(info.src);
+        info.value = info.onUpdate(newVal, info.value);
+        info.output();
+        consola.success(`[${sign}] Change "${info.src}"`);
+      });
+    }
+  }
+  async function parse(path, info) {
+    const stats = await fs.stat(path);
+    const hash = CryptoES.MD5(stats.size.toString()).toString();
+    let cache = caches[path];
+    if (isDev && cache?.hash === hash) {
+      info.onCacheHit?.(cache);
+      return false;
+    }
+    cache = { hash };
+    const data = await info.parse(path, info);
+    if (data !== null) {
+      cache = {
+        ...cache,
+        ...data ?? {}
+      };
+      info.onCacheHit?.(cache);
+      caches[path] = cache;
+    } else {
+      unlink(path, info);
+    }
+    return true;
+  }
+  async function add(path, info) {
+    const cache = caches[path];
+    if (cache) {
+      return false;
+    }
+    return await parse(path, info);
+  }
+  function unlink(path, info) {
+    const cache = caches[path];
+    if (!cache) {
+      return false;
+    }
+    info.unlink?.(cache);
+    delete caches[path];
+    return true;
+  }
+  function outputLoads() {
+    fs.outputJsonSync(cachePath, caches);
+    for (const info of ctx.loadInfos) {
+      info.output();
+    }
+  }
+  return {
+    build,
+    watch
+  };
+}
+
+// src/core/useLoad.ts
+import fs2 from "fs-extra";
+import { resolve } from "pathe";
+function useLoad(name, options) {
+  const ctx = useCurrentContext();
+  const src = options.src ? resolve(options.src) : void 0;
+  const out = resolve(options.out);
+  const {
+    defaultValue,
+    onUpdate,
+    beforeOutput
+  } = options;
+  const info = {
+    name,
+    src,
+    out,
+    value: src ? fs2.readJsonSync(src) : defaultValue ?? {},
+    output() {
+      const data = beforeOutput?.(info.value) ?? info.value;
+      fs2.outputJsonSync(info.out, data);
+    },
+    onUpdate
+  };
+  ctx.loadInfos.push(info);
+  onUpdate(info.value, void 0);
+  return info;
+}
+
+// src/core/useSource.ts
+import fs3 from "fs-extra";
+import { resolve as resolve2 } from "pathe";
+function useSource(kind, options) {
+  const ctx = useCurrentContext();
+  const base = resolve2(options.base);
+  const dist = options.dist ? resolve2(options.dist) : void 0;
+  const folders = options.folders?.map((folder) => resolve2(base, folder)) ?? [base];
+  const patterns = folders.map((path) => resolve2(path, `**/*${options.ext}`));
+  const info = {
+    ...options,
+    kind,
+    base,
+    dist,
+    folders,
+    patterns,
+    deep: options.deep ?? true,
+    skip: options.skip ?? 0,
+    filter(path) {
+      const depth = path.split("/").length - folders[0].split("/").length;
+      return info.skip < depth;
+    },
+    async output(path, data) {
+      const outPath = path.replace(base, dist).replace(info.ext, ".json");
+      await fs3.outputJson(outPath, data);
+    }
+  };
+  ctx.sourceInfos.push(info);
+  return info;
+}
+export {
+  createProcessor,
+  useCurrentContext,
+  useLoad,
+  useSource
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "kerria",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "",
+  "author": "KazariEX",
+  "license": "MIT",
+  "repository": "KazariEX/kerria",
+  "keywords": [],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "consola": "^3.4.0",
+    "crypto-es": "^2.1.0",
+    "find-cache-dir": "^5.0.0",
+    "fs-extra": "^11.3.0",
+    "pathe": "^2.0.2",
+    "tinyglobby": "^0.2.10"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4"
+  },
+  "scripts": {
+    "build": "tsup-node",
+    "dev": "tsup-node --watch",
+    "release": "bumpp --no-push -c \"release: v%s\"",
+    "test": "vitest"
+  }
+}