@aromix/core 0.0.0

package/dist/index.cjs

@@ -0,0 +1,553 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/build.ts
+function build(options) {
+  return options;
+}
+
+// src/config.ts
+function config(config2) {
+  return typeof config2 === "function" ? config2() : config2;
+}
+
+// src/entity/entity.ts
+function entity(options) {
+}
+
+// src/fetch/codec.ts
+var _msgpack = require('@msgpack/msgpack');
+var Codec = {
+  encode(data) {
+    return _msgpack.encode.call(void 0, data);
+  },
+  decode(buf) {
+    return _msgpack.decode.call(void 0, buf);
+  },
+  async fromRequest(req) {
+    const contentType = req.headers.get("content-type");
+    if (contentType !== "application/x-msgpack") {
+      throw new Error(`Invalid content-type "${contentType}" \u2014 only application/x-msgpack is accepted`);
+    }
+    const buf = await req.arrayBuffer();
+    if (buf.byteLength === 0) return void 0;
+    return _msgpack.decode.call(void 0, new Uint8Array(buf));
+  },
+  response(data) {
+    return new Response(_msgpack.encode.call(void 0, data), {
+      status: 200,
+      headers: { "Content-Type": "application/x-msgpack" }
+    });
+  }
+};
+
+// src/fetch/fetch.ts
+function toFetchHandler() {
+}
+
+// src/hook/impl.ts
+function hook(on, run) {
+  return { on, run };
+}
+
+// src/load.ts
+function detectRuntime() {
+  if (typeof globalThis.Deno !== "undefined") return "deno";
+  if (typeof globalThis.Bun !== "undefined") return "bun";
+  if (typeof process !== "undefined" && _optionalChain([process, 'access', _ => _.versions, 'optionalAccess', _2 => _2.node])) return "node";
+  return "worker";
+}
+var RUNTIME = detectRuntime();
+function makeNodeAdapter() {
+  const fs = __require("fs");
+  const path = __require("path");
+  const statCache = /* @__PURE__ */ new Map();
+  return {
+    cwd: () => process.cwd(),
+    readdir: (dir) => fs.readdirSync(dir),
+    lstat: (p) => {
+      if (statCache.has(p)) return statCache.get(p);
+      const s = fs.lstatSync(p);
+      const result = { isFile: s.isFile(), isDirectory: s.isDirectory() };
+      statCache.set(p, result);
+      return result;
+    },
+    exists: (p) => {
+      try {
+        fs.accessSync(p);
+        return true;
+      } catch (e2) {
+        return false;
+      }
+    },
+    readText: (p) => fs.readFileSync(p, "utf8"),
+    resolve: (...parts) => path.resolve(...parts),
+    join: (...parts) => path.join(...parts),
+    relative: (from, to) => path.relative(from, to),
+    sep: path.sep
+  };
+}
+function makeDenoAdapter() {
+  const deno = globalThis.Deno;
+  const statCache = /* @__PURE__ */ new Map();
+  const join = (...parts) => parts.reduce((a, b) => a.replace(/\/+$/, "") + "/" + b.replace(/^\/+/, ""));
+  const resolve = (...parts) => {
+    let base = parts[0].startsWith("/") ? parts[0] : join(deno.cwd(), parts[0]);
+    for (let i = 1; i < parts.length; i++) {
+      const p = parts[i];
+      base = p.startsWith("/") ? p : join(base, p);
+    }
+    const segments = base.split("/");
+    const out = [];
+    for (const s of segments) {
+      if (s === "..") out.pop();
+      else if (s !== ".") out.push(s);
+    }
+    return out.join("/") || "/";
+  };
+  return {
+    cwd: () => deno.cwd(),
+    readdir: (dir) => [...deno.readDirSync(dir)].map((e) => e.name),
+    lstat: (p) => {
+      if (statCache.has(p)) return statCache.get(p);
+      const s = deno.lstatSync(p);
+      const result = { isFile: s.isFile, isDirectory: s.isDirectory };
+      statCache.set(p, result);
+      return result;
+    },
+    exists: (p) => {
+      try {
+        deno.lstatSync(p);
+        return true;
+      } catch (e3) {
+        return false;
+      }
+    },
+    readText: (p) => deno.readTextFileSync(p),
+    resolve,
+    join,
+    relative: (from, to) => {
+      const f = from.split("/").filter(Boolean);
+      const t = to.split("/").filter(Boolean);
+      let i = 0;
+      while (i < f.length && f[i] === t[i]) i++;
+      return [...f.slice(i).map(() => ".."), ...t.slice(i)].join("/") || ".";
+    },
+    sep: "/"
+  };
+}
+function makeWorkerAdapter() {
+  const noFS = (method) => () => {
+    throw new Error(
+      `load(): filesystem access unavailable in Cloudflare Workers (called: ${method}). Only pre-resolved paths or alias-only patterns are supported.`
+    );
+  };
+  return {
+    cwd: noFS("cwd"),
+    readdir: noFS("readdir"),
+    lstat: noFS("lstat"),
+    exists: () => false,
+    readText: noFS("readText"),
+    resolve: (...parts) => parts.join("/").replace(/\/+/g, "/"),
+    join: (...parts) => parts.join("/").replace(/\/+/g, "/"),
+    relative: noFS("relative"),
+    sep: "/"
+  };
+}
+function makeAdapter() {
+  if (RUNTIME === "deno") return makeDenoAdapter();
+  if (RUNTIME === "worker") return makeWorkerAdapter();
+  return makeNodeAdapter();
+}
+function expandBraces(pattern) {
+  const open = pattern.indexOf("{");
+  if (open === -1) return [pattern];
+  let depth = 0;
+  let close = -1;
+  for (let i = open; i < pattern.length; i++) {
+    if (pattern[i] === "{") depth++;
+    else if (pattern[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        close = i;
+        break;
+      }
+    }
+  }
+  if (close === -1) return [pattern];
+  const prefix = pattern.slice(0, open);
+  const suffix = pattern.slice(close + 1);
+  const inner = pattern.slice(open + 1, close);
+  const parts = [];
+  let buf = "";
+  let d = 0;
+  for (const ch of inner) {
+    if (ch === "{") {
+      d++;
+      buf += ch;
+    } else if (ch === "}") {
+      d--;
+      buf += ch;
+    } else if (ch === "," && d === 0) {
+      parts.push(buf);
+      buf = "";
+    } else buf += ch;
+  }
+  parts.push(buf);
+  const results = [];
+  for (const part of parts) {
+    for (const expanded of expandBraces(prefix + part + suffix)) {
+      results.push(expanded);
+    }
+  }
+  return results;
+}
+function globToRegex(glob, opts = {}) {
+  let src = "^";
+  let i = 0;
+  const len = glob.length;
+  while (i < len) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        src += opts.globstar !== false ? ".*" : "[^/]*";
+        i += 2;
+        if (glob[i] === "/") i++;
+        continue;
+      }
+      src += "[^/]*";
+    } else if (ch === "?") {
+      src += "[^/]";
+    } else if (".+^${}|[]()\\".includes(ch)) {
+      src += "\\" + ch;
+    } else {
+      src += ch;
+    }
+    i++;
+  }
+  src += "$";
+  return new RegExp(src);
+}
+var HIDDEN = /(^|[/\\])\.[^/\\.]/;
+function walkSync(fs, baseDir, globParts, currentDir, opts) {
+  if (globParts.length === 0) return [];
+  const results = [];
+  const [head, ...rest] = globParts;
+  const isLast = rest.length === 0;
+  let entries;
+  try {
+    entries = fs.readdir(currentDir);
+  } catch (e4) {
+    return results;
+  }
+  if (head === "**") {
+    for (const name of entries) {
+      const full = fs.join(currentDir, name);
+      if (!opts.dot && HIDDEN.test(name)) continue;
+      let stat;
+      try {
+        stat = fs.lstat(full);
+      } catch (e5) {
+        continue;
+      }
+      if (stat.isDirectory) {
+        results.push(...walkSync(fs, baseDir, globParts, full, opts));
+        if (rest.length > 0) {
+          results.push(...walkSync(fs, baseDir, rest, full, opts));
+        }
+      } else if (stat.isFile) {
+        if (rest.length === 0) results.push(full);
+        else {
+        }
+      }
+    }
+    return results;
+  }
+  const regex = globToRegex(head, { globstar: false });
+  for (const name of entries) {
+    if (!opts.dot && HIDDEN.test(name)) continue;
+    if (!regex.test(name)) continue;
+    const full = fs.join(currentDir, name);
+    let stat;
+    try {
+      stat = fs.lstat(full);
+    } catch (e6) {
+      continue;
+    }
+    if (isLast) {
+      if (stat.isFile) results.push(full);
+      else if (stat.isDirectory && !opts.filesOnly) results.push(full);
+    } else {
+      if (stat.isDirectory) {
+        results.push(...walkSync(fs, baseDir, rest, full, opts));
+      }
+    }
+  }
+  return results;
+}
+function resolveGlob(fsAdapter, pattern, opts) {
+  const sep = /[/\\]/;
+  const parts = pattern.split(sep);
+  let staticParts = [];
+  let globParts = [];
+  let inGlob = false;
+  for (const p of parts) {
+    if (!inGlob && !p.includes("*") && !p.includes("?")) {
+      staticParts.push(p);
+    } else {
+      inGlob = true;
+      globParts.push(p);
+    }
+  }
+  const baseDir = fsAdapter.resolve(opts.cwd, staticParts.join("/"));
+  if (globParts.length === 0) {
+    try {
+      const stat = fsAdapter.lstat(baseDir);
+      if (opts.filesOnly && !stat.isFile) return [];
+      return [baseDir];
+    } catch (e7) {
+      return [];
+    }
+  }
+  return walkSync(fsAdapter, baseDir, globParts, baseDir, opts);
+}
+var aliasCache = /* @__PURE__ */ new Map();
+function findTsconfig(fsAdapter, startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = fsAdapter.join(dir, "tsconfig.json");
+    if (fsAdapter.exists(candidate)) return candidate;
+    const parent = fsAdapter.resolve(dir, "..");
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function loadTsconfig(fsAdapter, tsconfigPath) {
+  if (aliasCache.has(tsconfigPath)) return aliasCache.get(tsconfigPath);
+  try {
+    const raw = fsAdapter.readText(tsconfigPath);
+    const cleaned = raw.replace(/\/\/[^\n]*/g, "");
+    const json = JSON.parse(cleaned);
+    const co = _nullishCoalesce(_optionalChain([json, 'optionalAccess', _3 => _3.compilerOptions]), () => ( {}));
+    const baseUrl = co.baseUrl ? fsAdapter.resolve(fsAdapter.join(tsconfigPath, ".."), co.baseUrl) : fsAdapter.join(tsconfigPath, "..");
+    const paths = _nullishCoalesce(co.paths, () => ( {}));
+    const result = { paths, baseUrl };
+    aliasCache.set(tsconfigPath, result);
+    return result;
+  } catch (e8) {
+    aliasCache.set(tsconfigPath, null);
+    return null;
+  }
+}
+function resolveAliases(pattern, aliasMap) {
+  const { paths, baseUrl } = aliasMap;
+  for (const [key, targets] of Object.entries(paths)) {
+    const aliasRegex = new RegExp("^" + key.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "(.*)") + "$");
+    const match = pattern.match(aliasRegex);
+    if (!match) continue;
+    const capture = _nullishCoalesce(match[1], () => ( ""));
+    return targets.map((target) => {
+      const concrete = target.includes("*") ? target.replace("*", capture) : target;
+      return concrete.startsWith("/") ? concrete : `${baseUrl}/${concrete}`.replace(/\/+/g, "/");
+    });
+  }
+  return [pattern];
+}
+function load(pattern, options = {}) {
+  const fsAdapter = makeAdapter();
+  const cwd = _nullishCoalesce(options.cwd, () => ( (RUNTIME !== "worker" ? fsAdapter.cwd() : "/")));
+  const dot = _nullishCoalesce(options.dot, () => ( false));
+  const filesOnly = _nullishCoalesce(options.filesOnly, () => ( true));
+  let aliasMap = null;
+  if (RUNTIME !== "worker") {
+    const tsconfigPath = options.tsconfig ? fsAdapter.resolve(cwd, options.tsconfig) : findTsconfig(fsAdapter, cwd);
+    if (tsconfigPath) {
+      aliasMap = loadTsconfig(fsAdapter, tsconfigPath);
+    }
+  }
+  const patterns = Array.isArray(pattern) ? pattern : [pattern];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const rawPattern of patterns) {
+    const aliasExpanded = aliasMap ? resolveAliases(rawPattern, aliasMap) : [rawPattern];
+    for (const aliasPattern of aliasExpanded) {
+      const braceExpanded = expandBraces(aliasPattern);
+      for (const globPattern of braceExpanded) {
+        if (RUNTIME === "worker") {
+          if (!seen.has(globPattern)) {
+            seen.add(globPattern);
+            results.push(globPattern);
+          }
+          continue;
+        }
+        const matches = resolveGlob(fsAdapter, globPattern, { cwd, dot, filesOnly });
+        for (const m of matches) {
+          if (!seen.has(m)) {
+            seen.add(m);
+            results.push(m);
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function clearCache() {
+  aliasCache.clear();
+}
+
+// src/make/impl.ts
+function make() {
+}
+
+// src/make/util.ts
+function filter(hooks, on) {
+  return hooks.filter((h) => h.on === on).map((h) => h.run);
+}
+
+// src/plugin.ts
+function plugin() {
+}
+
+// src/program/types.ts
+var programMeta = /* @__PURE__ */ Symbol("aromix.program.meta");
+
+// src/program/impl.ts
+function program(config2) {
+  const meta = {
+    name: config2.name,
+    deps: _nullishCoalesce(config2.deps, () => ( {})),
+    hooks: _nullishCoalesce(config2.hooks, () => ( [])),
+    routes: []
+  };
+  return {
+    [programMeta]: meta,
+    command(options) {
+      meta.routes.push({
+        type: "command",
+        options
+      });
+    },
+    stream(options) {
+      meta.routes.push({
+        type: "stream",
+        options
+      });
+    },
+    socket(options) {
+      meta.routes.push({
+        type: "socket",
+        options
+      });
+    }
+  };
+}
+
+// src/service/facade.ts
+function hasKey(obj, key) {
+  if (typeof key === "symbol") {
+    return Object.getOwnPropertySymbols(obj).includes(key);
+  }
+  return Object.hasOwn(obj, key);
+}
+var NativeKeys = /* @__PURE__ */ new Set([
+  ...Object.getOwnPropertyNames(Object.prototype),
+  ...Object.getOwnPropertySymbols(Object.prototype),
+  ...Object.getOwnPropertyNames(Function.prototype),
+  ...Object.getOwnPropertySymbols(Function.prototype)
+]);
+function addInstanceProperties(serviceInstance, targetObj) {
+  const ownKeys = [...Object.getOwnPropertyNames(serviceInstance), ...Object.getOwnPropertySymbols(serviceInstance)];
+  for (const key of ownKeys) {
+    if (hasKey(targetObj, key)) continue;
+    const descriptor = Object.getOwnPropertyDescriptor(serviceInstance, key);
+    if (typeof descriptor.value === "function") continue;
+    if (descriptor.get || descriptor.set) continue;
+    Object.defineProperty(targetObj, key, {
+      get: () => serviceInstance[key],
+      set: (v) => serviceInstance[key] = v,
+      enumerable: true,
+      configurable: true
+    });
+  }
+}
+function addPrototypeProperties(serviceInstance, targetObj) {
+  let currentProto = Object.getPrototypeOf(serviceInstance);
+  while (currentProto && currentProto !== Object.prototype) {
+    const protoKeys = [...Object.getOwnPropertyNames(currentProto), ...Object.getOwnPropertySymbols(currentProto)];
+    for (const key of protoKeys) {
+      if (hasKey(targetObj, key)) continue;
+      if (NativeKeys.has(key)) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(currentProto, key);
+      if (descriptor.get || descriptor.set) {
+        Object.defineProperty(targetObj, key, {
+          get: descriptor.get ? () => descriptor.get.call(serviceInstance) : void 0,
+          set: descriptor.set ? (v) => descriptor.set.call(serviceInstance, v) : void 0,
+          enumerable: true,
+          configurable: true
+        });
+      } else if (typeof descriptor.value === "function") {
+        targetObj[key] = descriptor.value.bind(serviceInstance);
+      }
+    }
+    currentProto = Object.getPrototypeOf(currentProto);
+  }
+}
+function createFacadeObj(serviceInstance) {
+  const targetObj = {};
+  addInstanceProperties(serviceInstance, targetObj);
+  addPrototypeProperties(serviceInstance, targetObj);
+  Object.defineProperty(targetObj, "constructor", {
+    get: () => serviceInstance.constructor,
+    enumerable: false,
+    configurable: true
+  });
+  return targetObj;
+}
+
+// src/service/service.ts
+var ServiceToken = /* @__PURE__ */ Symbol.for("aromix.service.token");
+var ServiceRegistry = /* @__PURE__ */ new Map();
+function provide() {
+  return (target) => {
+    const token = crypto.randomUUID();
+    target[ServiceToken] = token;
+  };
+}
+function inject(Service) {
+  const token = Service[ServiceToken];
+  if (!token) {
+    throw new Error(`Class ${Service.name} is not marked as injectable. Use @provide().`);
+  }
+  if (!ServiceRegistry.has(token)) {
+    ServiceRegistry.set(Service, new Service());
+  }
+  let instance = ServiceRegistry.get(Service);
+  return instance;
+}
+inject.facade = (Service) => {
+  const instance = inject(Service);
+  return createFacadeObj(instance);
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Codec = Codec; exports.build = build; exports.clearCache = clearCache; exports.config = config; exports.createFacadeObj = createFacadeObj; exports.entity = entity; exports.filter = filter; exports.hook = hook; exports.inject = inject; exports.load = load; exports.make = make; exports.plugin = plugin; exports.program = program; exports.programMeta = programMeta; exports.provide = provide; exports.toFetchHandler = toFetchHandler;