@resourcexjs/core 2.4.1 → 2.5.1

package/dist/index.js

@@ -28,135 +28,56 @@ class ContentError extends ResourceXError {
     this.name = "ContentError";
   }
 }
-// src/locator/parseRXL.ts
-class RXLImpl {
-  domain;
-  path;
-  name;
-  type;
-  version;
-  constructor(parts) {
-    this.domain = parts.domain;
-    this.path = parts.path;
-    this.name = parts.name;
-    this.type = parts.type;
-    this.version = parts.version;
-  }
-  toString() {
-    let result = "";
-    if (this.domain) {
-      result += this.domain + "/";
-      if (this.path) {
-        result += this.path + "/";
-      }
-    }
-    result += this.name;
-    if (this.type) {
-      result += "." + this.type;
-    }
-    if (this.version) {
-      result += "@" + this.version;
-    }
-    return result;
+
+class DefinitionError extends ResourceXError {
+  constructor(message) {
+    super(message);
+    this.name = "DefinitionError";
   }
 }
-function isDomain(str) {
-  if (str === "localhost")
-    return true;
-  return str.includes(".");
-}
-function parseRXL(locator) {
-  let remaining = locator;
-  let version;
-  let type;
-  let domain;
-  let path;
-  let name;
-  const atIndex = remaining.indexOf("@");
-  if (atIndex !== -1) {
-    version = remaining.slice(atIndex + 1);
-    remaining = remaining.slice(0, atIndex);
-  }
-  const segments = remaining.split("/");
-  if (segments.length > 1 && isDomain(segments[0])) {
-    domain = segments[0];
-    const lastSegment = segments[segments.length - 1];
-    if (segments.length > 2) {
-      path = segments.slice(1, -1).join("/");
-    }
-    remaining = lastSegment;
-  } else {
-    remaining = segments.join("/");
+// src/primitives/define.ts
+function define(input) {
+  if (input === null || typeof input !== "object") {
+    throw new DefinitionError("definition must be an object");
   }
-  const dotIndex = remaining.lastIndexOf(".");
-  if (dotIndex !== -1) {
-    type = remaining.slice(dotIndex + 1);
-    name = remaining.slice(0, dotIndex);
-  } else {
-    name = remaining;
+  const obj = input;
+  if (!obj.name || typeof obj.name !== "string") {
+    throw new DefinitionError("name is required");
   }
-  return new RXLImpl({ domain, path, name, type, version });
-}
-// src/manifest/createRXM.ts
-class RXMImpl {
-  domain;
-  path;
-  name;
-  type;
-  version;
-  constructor(data) {
-    this.domain = data.domain;
-    this.path = data.path;
-    this.name = data.name;
-    this.type = data.type;
-    this.version = data.version;
+  if (!obj.type || typeof obj.type !== "string") {
+    throw new DefinitionError("type is required");
   }
-  toLocator() {
-    let result = this.domain + "/";
-    if (this.path) {
-      result += this.path + "/";
-    }
-    result += this.name;
-    result += "." + this.type;
-    result += "@" + this.version;
-    return result;
-  }
-  toJSON() {
-    const json = {
-      domain: this.domain,
-      name: this.name,
-      type: this.type,
-      version: this.version
-    };
-    if (this.path !== undefined) {
-      json.path = this.path;
-    }
-    return json;
+  const tagValue = obj.tag ?? obj.version;
+  if (tagValue !== undefined && typeof tagValue !== "string") {
+    throw new DefinitionError("tag must be a string");
   }
+  const rxd = {
+    ...obj,
+    name: obj.name,
+    type: obj.type,
+    tag: typeof tagValue === "string" ? tagValue : undefined,
+    registry: typeof obj.registry === "string" ? obj.registry : undefined,
+    path: typeof obj.path === "string" ? obj.path : undefined,
+    description: typeof obj.description === "string" ? obj.description : undefined,
+    author: typeof obj.author === "string" ? obj.author : undefined,
+    license: typeof obj.license === "string" ? obj.license : undefined,
+    keywords: Array.isArray(obj.keywords) ? obj.keywords : undefined,
+    repository: typeof obj.repository === "string" ? obj.repository : undefined
+  };
+  return rxd;
 }
-function createRXM(data) {
-  if (!data.domain) {
-    throw new ManifestError("domain is required");
-  }
-  if (!data.name) {
-    throw new ManifestError("name is required");
-  }
-  if (!data.type) {
-    throw new ManifestError("type is required");
-  }
-  if (!data.version) {
-    throw new ManifestError("version is required");
-  }
-  return new RXMImpl({
-    domain: data.domain,
-    path: data.path,
-    name: data.name,
-    type: data.type,
-    version: data.version
-  });
+// src/primitives/manifest.ts
+function manifest(rxd) {
+  return {
+    registry: rxd.registry,
+    path: rxd.path,
+    name: rxd.name,
+    type: rxd.type,
+    tag: rxd.tag ?? "latest"
+  };
 }
-// src/archive/createRXA.ts
-import { gzip, gunzip } from "node:zlib";
+// src/primitives/archive.ts
+import { gzip } from "node:zlib";
 import { promisify } from "node:util";
 
 // ../../node_modules/.bun/modern-tar@0.7.3/node_modules/modern-tar/dist/unpacker-BpPBxY8N.js
@@ -1136,85 +1057,159 @@ async function unpackTar(archive, options = {}) {
   return results;
 }
 
-// src/archive/createRXA.ts
+// src/primitives/archive.ts
 var gzipAsync = promisify(gzip);
-var gunzipAsync = promisify(gunzip);
 
-class RXPImpl {
-  _files;
-  _pathsCache = null;
-  _treeCache = null;
-  constructor(files) {
-    this._files = files;
-  }
-  paths() {
-    if (this._pathsCache) {
-      return this._pathsCache;
-    }
-    this._pathsCache = Array.from(this._files.keys()).sort();
-    return this._pathsCache;
+class RXAImpl {
+  _buffer;
+  constructor(buffer) {
+    this._buffer = buffer;
   }
-  tree() {
-    if (this._treeCache) {
-      return this._treeCache;
-    }
-    const root = new Map;
-    for (const path of this._files.keys()) {
-      const parts = path.split("/");
-      let currentLevel = root;
-      for (let i = 0;i < parts.length; i++) {
-        const part = parts[i];
-        const isFile = i === parts.length - 1;
-        if (!currentLevel.has(part)) {
-          const treeNode2 = {
-            node: {
-              name: part,
-              type: isFile ? "file" : "directory",
-              children: isFile ? undefined : []
-            },
-            children: new Map
-          };
-          currentLevel.set(part, treeNode2);
-        }
-        const treeNode = currentLevel.get(part);
-        if (!isFile) {
-          currentLevel = treeNode.children;
-        }
+  get stream() {
+    const buffer = this._buffer;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(buffer));
+        controller.close();
       }
-    }
-    const convertToPathNodes = (level) => {
-      return Array.from(level.values()).map((treeNode) => {
-        if (treeNode.node.type === "directory" && treeNode.children.size > 0) {
-          treeNode.node.children = convertToPathNodes(treeNode.children);
-        }
-        return treeNode.node;
-      });
-    };
-    this._treeCache = convertToPathNodes(root);
-    return this._treeCache;
+    });
+  }
+  async buffer() {
+    return this._buffer;
   }
-  async file(path) {
-    const content = this._files.get(path);
-    if (!content) {
-      throw new ContentError(`file not found: ${path}`);
+}
+async function archive(files) {
+  const entries = Object.entries(files).map(([name, content]) => {
+    return {
+      header: { name, size: content.length, type: "file" },
+      body: new Uint8Array(content)
+    };
+  });
+  const tarBuffer = await packTar(entries);
+  const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
+  return new RXAImpl(gzipBuffer);
+}
+// src/primitives/locate.ts
+function locate(rxm) {
+  return {
+    registry: rxm.registry,
+    path: rxm.path,
+    name: rxm.name,
+    tag: rxm.tag
+  };
+}
+// src/primitives/resource.ts
+function resource(rxm, rxa) {
+  const rxl = locate(rxm);
+  return {
+    locator: rxl,
+    manifest: rxm,
+    archive: rxa
+  };
+}
+// src/primitives/extract.ts
+import { gunzip } from "node:zlib";
+import { promisify as promisify2 } from "node:util";
+var gunzipAsync = promisify2(gunzip);
+async function extract(rxa) {
+  const buffer = await rxa.buffer();
+  const tarBuffer = await gunzipAsync(buffer);
+  const entries = await unpackTar(tarBuffer);
+  const files = {};
+  for (const entry of entries) {
+    if ((entry.header.type === "file" || entry.header.type === undefined) && entry.data) {
+      files[entry.header.name] = Buffer.from(entry.data);
     }
-    return content;
   }
-  async files() {
-    return new Map(this._files);
+  return files;
+}
+// src/primitives/format.ts
+function format(rxl) {
+  let result = "";
+  if (rxl.registry) {
+    result += rxl.registry + "/";
   }
-  async pack() {
-    const filesRecord = {};
-    for (const [path, content] of this._files) {
-      filesRecord[path] = content;
-    }
-    return createRXA(filesRecord);
+  if (rxl.path) {
+    result += rxl.path + "/";
   }
+  result += rxl.name;
+  if (rxl.tag && rxl.tag !== "latest") {
+    result += ":" + rxl.tag;
+  }
+  return result;
 }
-
-class RXAImpl {
+// src/primitives/parse.ts
+function looksLikeRegistry(str) {
+  if (str.includes(":") && !str.includes("/")) {
+    return true;
+  }
+  if (str.includes(".")) {
+    return true;
+  }
+  if (str === "localhost") {
+    return true;
+  }
+  return false;
+}
+function parse(locator) {
+  if (!locator || typeof locator !== "string") {
+    throw new LocatorError("Locator must be a non-empty string", locator);
+  }
+  if (locator.includes("@")) {
+    throw new LocatorError("Invalid locator format. Use name:tag instead of name@version", locator);
+  }
+  const lastSlashIndex = locator.lastIndexOf("/");
+  let beforeSlash = "";
+  let afterSlash = locator;
+  if (lastSlashIndex !== -1) {
+    beforeSlash = locator.substring(0, lastSlashIndex);
+    afterSlash = locator.substring(lastSlashIndex + 1);
+  }
+  const colonIndex = afterSlash.lastIndexOf(":");
+  let name;
+  let tag;
+  if (colonIndex === -1) {
+    name = afterSlash;
+    tag = "latest";
+  } else {
+    name = afterSlash.substring(0, colonIndex);
+    tag = afterSlash.substring(colonIndex + 1);
+  }
+  if (!name) {
+    throw new LocatorError("Name is required", locator);
+  }
+  if (!tag) {
+    throw new LocatorError("Tag cannot be empty. Use name:tag format or omit tag for :latest", locator);
+  }
+  if (lastSlashIndex === -1) {
+    return {
+      registry: undefined,
+      path: undefined,
+      name,
+      tag
+    };
+  }
+  const parts = beforeSlash.split("/");
+  if (looksLikeRegistry(parts[0])) {
+    const registry = parts[0];
+    const path = parts.length > 1 ? parts.slice(1).join("/") : undefined;
+    return {
+      registry,
+      path,
+      name,
+      tag
+    };
+  }
+  return {
+    registry: undefined,
+    path: beforeSlash,
+    name,
+    tag
+  };
+}
+// src/primitives/wrap.ts
+class RXAImpl2 {
   _buffer;
-  _rxpCache = null;
   constructor(buffer) {
     this._buffer = buffer;
   }
@@ -1230,49 +1225,25 @@ class RXAImpl {
   async buffer() {
     return this._buffer;
   }
-  async extract() {
-    if (this._rxpCache) {
-      return this._rxpCache;
-    }
-    const tarBuffer = await gunzipAsync(this._buffer);
-    const entries = await unpackTar(tarBuffer);
-    const filesMap = new Map;
-    for (const entry of entries) {
-      if ((entry.header.type === "file" || entry.header.type === undefined) && entry.data) {
-        filesMap.set(entry.header.name, Buffer.from(entry.data));
-      }
-    }
-    this._rxpCache = new RXPImpl(filesMap);
-    return this._rxpCache;
-  }
-}
-function isBufferInput(input) {
-  return "buffer" in input && Buffer.isBuffer(input.buffer);
 }
-async function createRXA(input) {
-  if (isBufferInput(input)) {
-    return new RXAImpl(input.buffer);
-  }
-  const entries = Object.entries(input).map(([name, content]) => {
-    const body = typeof content === "string" ? content : content instanceof Uint8Array ? content : new Uint8Array(content);
-    const size = typeof content === "string" ? Buffer.byteLength(content) : content.length;
-    return {
-      header: { name, size, type: "file" },
-      body
-    };
-  });
-  const tarBuffer = await packTar(entries);
-  const gzipBuffer = await gzipAsync(Buffer.from(tarBuffer));
-  return new RXAImpl(gzipBuffer);
+function wrap(buffer) {
+  return new RXAImpl2(buffer);
 }
 export {
-  parseRXL,
-  createRXM,
-  createRXA,
+  wrap,
+  resource,
+  parse,
+  manifest,
+  locate,
+  format,
+  extract,
+  define,
+  archive,
   ResourceXError,
   ManifestError,
   LocatorError,
+  DefinitionError,
   ContentError
 };
 
-//# debugId=AFABB314B72836D164756E2164756E21
+//# debugId=E36D0778C816F02964756E2164756E21