wyvrnpm 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyvrnpm",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "A simple, static-hosting-compatible C++ package manager",
   "keywords": [
     "c++",

package/src/commands/publish.js

@@ -8,6 +8,69 @@ const { readManifest } = require('../manifest');
 const { getProvider } = require('../providers');
 const { readConfig } = require('../config');
 
+/**
+ * Parse a .wyvrnignore file and return an array of pattern strings.
+ * Lines starting with '#' and blank lines are ignored.
+ */
+function loadIgnorePatterns(ignoreFile) {
+  if (!fs.existsSync(ignoreFile)) return [];
+  return fs
+    .readFileSync(ignoreFile, 'utf8')
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0 && !l.startsWith('#'));
+}
+
+/**
+ * Convert a glob-style ignore pattern to a RegExp.
+ * Supports '*', '**', '?' wildcards and leading '/' to anchor to root.
+ */
+function patternToRegex(pattern) {
+  // A leading slash means "anchored to root"; strip it and keep the rest
+  const anchored = pattern.startsWith('/');
+  const p = anchored ? pattern.slice(1) : pattern;
+
+  let re = p
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex special chars
+    .replace(/\*\*/g, '\x00')              // placeholder for **
+    .replace(/\*/g, '[^/]*')              // * → match within segment
+    .replace(/\?/g, '[^/]')              // ? → single non-slash char
+    .replace(/\x00/g, '.*');             // ** → match across segments
+
+  // If anchored, match from the start; otherwise match any path segment
+  return anchored ? new RegExp(`^${re}(/|$)`) : new RegExp(`(^|/)${re}(/|$)`);
+}
+
+/**
+ * Recursively add files from `dir` into `zip`, skipping any path that
+ * matches one of the compiled ignore regexes.
+ *
+ * @param {AdmZip} zip
+ * @param {string} dir        Absolute path of the directory being zipped
+ * @param {string} base       Absolute path of the root publish directory
+ * @param {RegExp[]} ignoreRe Compiled ignore patterns
+ */
+function addFolderFiltered(zip, dir, base, ignoreRe) {
+  for (const entry of fs.readdirSync(dir)) {
+    const fullPath = path.join(dir, entry);
+    // Relative path from publish root, always using forward slashes
+    const relPath = path.relative(base, fullPath).replace(/\\/g, '/');
+
+    if (ignoreRe.some((re) => re.test(relPath))) {
+      console.log(`[wyvrn]   Ignoring: ${relPath}`);
+      continue;
+    }
+
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      addFolderFiltered(zip, fullPath, base, ignoreRe);
+    } else {
+      const zipDir = path.dirname(relPath).replace(/\\/g, '/');
+      zip.addLocalFile(fullPath, zipDir === '.' ? '' : zipDir);
+    }
+  }
+}
+
 async function publish(argv) {
   let { source, profile, platform, path: publishPath, token, manifest: manifestArg } = argv;
 
@@ -74,12 +137,20 @@ async function publish(argv) {
     `[wyvrn] Publishing ${name}@${version} (${targetPlatform}) via ${provider.constructor.providerName} provider`,
   );
 
+  // Load .wyvrnignore patterns from the publish directory
+  const ignoreFile = path.join(srcDir, '.wyvrnignore');
+  const ignorePatterns = loadIgnorePatterns(ignoreFile);
+  const ignoreRe = ignorePatterns.map(patternToRegex);
+  if (ignorePatterns.length > 0) {
+    console.log(`[wyvrn] Loaded ${ignorePatterns.length} pattern(s) from .wyvrnignore`);
+  }
+
   // Build a temporary zip of the publish directory
   const tmpZipPath = path.join(os.tmpdir(), `wyvrnpm-${name}-${version}-${Date.now()}.zip`);
   try {
     console.log(`[wyvrn] Zipping ${srcDir} ...`);
     const zip = new AdmZip();
-    zip.addLocalFolder(srcDir);
+    addFolderFiltered(zip, srcDir, srcDir, ignoreRe);
     zip.writeZip(tmpZipPath);
 
     await provider.publish(

package/src/resolve.js

@@ -132,12 +132,20 @@ async function resolveDependencies(rootDeps, packageSources, platform, httpClien
       continue;
     }
 
-    // razer.json uses PascalCase: { Dependencies: [ { Name, Version }, ... ] }
-    const deps = Array.isArray(manifest.Dependencies) ? manifest.Dependencies : [];
+    // Support both formats:
+    //   PascalCase array: { Dependencies: [ { Name, Version }, ... ] }
+    //   lowercase object: { dependencies: { name: version, ... } }
+    let deps = [];
+    if (Array.isArray(manifest.Dependencies)) {
+      deps = manifest.Dependencies.filter((d) => d.Name && d.Version).map((d) => ({
+        name: d.Name,
+        version: d.Version,
+      }));
+    } else if (manifest.dependencies && typeof manifest.dependencies === 'object') {
+      deps = Object.entries(manifest.dependencies).map(([name, version]) => ({ name, version }));
+    }
     for (const dep of deps) {
-      if (dep.Name && dep.Version) {
-        queue.push({ name: dep.Name, version: dep.Version });
-      }
+      queue.push({ name: dep.name, version: dep.version });
     }
   }