@ionify/ionify 0.1.1 → 0.1.2

package/dist/cache-Y4NMRSZO.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  clearCache,
+  getCacheKey,
+  readCache,
+  writeCache
+} from "./chunk-GOZUBOYH.js";
+export {
+  clearCache,
+  getCacheKey,
+  readCache,
+  writeCache
+};

package/dist/cas-FEOXFD7R.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import {
+  getCasArtifactPath
+} from "./chunk-X5UIMJDA.js";
+export {
+  getCasArtifactPath
+};

package/dist/chunk-GOZUBOYH.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+
+// src/core/cache.ts
+import fs2 from "fs";
+import path2 from "path";
+import crypto from "crypto";
+
+// src/native/index.ts
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+
+// src/core/version.ts
+import { createHash } from "crypto";
+function normalizeTreeshake(treeshake) {
+  if (treeshake === false || treeshake === void 0 || treeshake === null) {
+    return null;
+  }
+  if (treeshake === true) {
+    return {
+      mode: "safe",
+      include: [],
+      exclude: []
+    };
+  }
+  if (typeof treeshake === "string") {
+    return {
+      mode: treeshake === "aggressive" ? "aggressive" : "safe",
+      include: [],
+      exclude: []
+    };
+  }
+  return {
+    mode: treeshake.mode === "aggressive" ? "aggressive" : "safe",
+    include: Array.isArray(treeshake.include) ? [...treeshake.include].sort() : [],
+    exclude: Array.isArray(treeshake.exclude) ? [...treeshake.exclude].sort() : []
+  };
+}
+function normalizeScopeHoist(scopeHoist) {
+  if (scopeHoist === false || scopeHoist === void 0 || scopeHoist === null) {
+    return null;
+  }
+  if (scopeHoist === true) {
+    return {
+      inlineFunctions: true,
+      constantFolding: true,
+      combineVariables: true
+    };
+  }
+  return {
+    inlineFunctions: scopeHoist.inlineFunctions === true,
+    constantFolding: scopeHoist.constantFolding === true,
+    combineVariables: scopeHoist.combineVariables === true
+  };
+}
+function computeCanonicalVersionInputs(config) {
+  const parserMode = config.parserMode || "hybrid";
+  const minifier = config.minifier || "auto";
+  const treeshake = normalizeTreeshake(config.treeshake);
+  const scopeHoist = normalizeScopeHoist(config.scopeHoist);
+  const plugins = Array.isArray(config.plugins) ? config.plugins.map((p) => typeof p === "string" ? p : p.name).filter((name) => typeof name === "string").sort() : [];
+  let entry = null;
+  if (config.entry) {
+    if (typeof config.entry === "string") {
+      entry = [config.entry];
+    } else if (Array.isArray(config.entry)) {
+      entry = [...config.entry].sort();
+    }
+  }
+  const cssOptions = config.cssOptions && Object.keys(config.cssOptions).length > 0 ? config.cssOptions : null;
+  const assetOptions = config.assetOptions && Object.keys(config.assetOptions).length > 0 ? config.assetOptions : null;
+  return {
+    parserMode,
+    minifier,
+    treeshake,
+    scopeHoist,
+    plugins,
+    entry,
+    cssOptions,
+    assetOptions
+  };
+}
+function computeVersionHash(inputs) {
+  const json = JSON.stringify(inputs, Object.keys(inputs).sort());
+  const hash = createHash("sha256").update(json).digest("hex");
+  return hash.slice(0, 16);
+}
+
+// src/native/index.ts
+function resolveCandidates() {
+  const cwd = process.cwd();
+  const releaseDir = path.resolve(cwd, "target", "release");
+  const debugDir = path.resolve(cwd, "target", "debug");
+  const nativeDir = path.resolve(cwd, "native");
+  const moduleDir = path.dirname(new URL(import.meta.url).pathname);
+  const packageNativeDir = path.resolve(moduleDir, "..", "native");
+  const packageDistDir = path.resolve(moduleDir, "..");
+  const platformFile = process.platform === "win32" ? "ionify_core.dll" : process.platform === "darwin" ? "libionify_core.dylib" : "libionify_core.so";
+  const candidates = [
+    // Installed package locations (checked first)
+    path.join(packageDistDir, "ionify_core.node"),
+    path.join(packageNativeDir, "ionify_core.node"),
+    // Development locations
+    path.join(nativeDir, "ionify_core.node"),
+    path.join(releaseDir, "ionify_core.node"),
+    path.join(releaseDir, platformFile),
+    path.join(debugDir, "ionify_core.node"),
+    path.join(debugDir, platformFile)
+  ];
+  return candidates.filter((candidate) => {
+    try {
+      return fs.existsSync(candidate) && fs.statSync(candidate).isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+var nativeBinding = null;
+(() => {
+  const require2 = createRequire(import.meta.url);
+  for (const candidate of resolveCandidates()) {
+    try {
+      const mod = require2(candidate);
+      if (mod) {
+        nativeBinding = mod;
+        break;
+      }
+    } catch {
+    }
+  }
+})();
+var native = nativeBinding;
+function tryNativeTransform(mode, code, options) {
+  if (!nativeBinding) return null;
+  const wantsOxc = mode === "oxc" || mode === "hybrid";
+  const wantsSwc = mode === "swc" || mode === "hybrid";
+  if (wantsOxc && nativeBinding.parseAndTransformOxc) {
+    try {
+      return nativeBinding.parseAndTransformOxc(code, options);
+    } catch (err) {
+      if (mode === "oxc") throw err;
+    }
+  }
+  if (wantsSwc && nativeBinding.parseAndTransformSwc) {
+    try {
+      return nativeBinding.parseAndTransformSwc(code, options);
+    } catch (err) {
+      if (mode === "swc") throw err;
+    }
+  }
+  return null;
+}
+function ensureNativeGraph(graphPath, version) {
+  if (!nativeBinding?.graphInit) return;
+  try {
+    nativeBinding.graphInit(graphPath, version);
+  } catch (err) {
+    console.error(`[Native] Failed to initialize graph: ${err}`);
+  }
+}
+function computeGraphVersion(inputs) {
+  const canonical = computeCanonicalVersionInputs(inputs);
+  return computeVersionHash(canonical);
+}
+function tryBundleNodeModule(filePath, code) {
+  if (!nativeBinding?.plannerPlanBuild || !nativeBinding?.buildChunks) {
+    return null;
+  }
+  try {
+    const plan = nativeBinding.plannerPlanBuild([filePath]);
+    if (!plan || !plan.chunks || plan.chunks.length === 0) {
+      return null;
+    }
+    const artifacts = nativeBinding.buildChunks(plan);
+    if (artifacts && artifacts.length > 0 && artifacts[0].code) {
+      return artifacts[0].code;
+    }
+  } catch (error) {
+    console.warn(`[Ionify] Native bundler failed for ${filePath}:`, error);
+  }
+  return null;
+}
+
+// src/core/cache.ts
+var CACHE_DIR = path2.join(process.cwd(), ".ionify", "cache");
+function ensureCacheDir() {
+  if (!fs2.existsSync(CACHE_DIR)) {
+    fs2.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+function getCacheKey(content) {
+  if (native?.cacheHash) {
+    try {
+      return native.cacheHash(Buffer.from(content));
+    } catch {
+    }
+  }
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+function writeCache(hash, data) {
+  ensureCacheDir();
+  const target = path2.join(CACHE_DIR, hash);
+  fs2.writeFileSync(target, data);
+}
+function readCache(hash) {
+  const target = path2.join(CACHE_DIR, hash);
+  return fs2.existsSync(target) ? fs2.readFileSync(target) : null;
+}
+function clearCache() {
+  if (fs2.existsSync(CACHE_DIR)) {
+    fs2.rmSync(CACHE_DIR, { recursive: true, force: true });
+  }
+}
+
+export {
+  native,
+  tryNativeTransform,
+  ensureNativeGraph,
+  computeGraphVersion,
+  tryBundleNodeModule,
+  getCacheKey,
+  writeCache,
+  readCache,
+  clearCache
+};

package/dist/chunk-X5UIMJDA.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+// src/core/utils/cas.ts
+import path from "path";
+function getCasArtifactPath(casRoot, versionHash, moduleHash) {
+  return path.join(casRoot, versionHash, moduleHash);
+}
+
+export {
+  getCasArtifactPath
+};