@graphty/graph-io 0.3.47 → 0.3.48

package/dist/chunks/cx-export-BEeF6ymo.js

@@ -0,0 +1,259 @@
+import { GraphFormatError } from "@graphty/graph-format";
+import { L as LOSS } from "./export-CZ7VRm4I.js";
+import { p as plural, a as agree } from "./report-CgdsL9Hb.js";
+const RAW = `${String.fromCodePoint(0)}cx:`;
+const RAW_JSON = /"\\u0000cx:(-?\d+)"/g;
+const BIG_INTEGER_TEXT = /^-?[1-9]\d{15,}$/;
+function writableId(id) {
+  return typeof id === "number" ? Number.isSafeInteger(id) : BIG_INTEGER_TEXT.test(id) && !Number.isSafeInteger(Number(id));
+}
+function writtenIds(snapshot, mode, format) {
+  const { ids } = snapshot;
+  const bad = [];
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < ids.size; i++) {
+    const id = ids.idOf(i);
+    if (!writableId(id)) {
+      bad.push(i);
+    } else if (typeof id === "number") {
+      used.add(id);
+    }
+  }
+  if (bad.length > 0 && mode === "error") {
+    const first = ids.idOf(bad[0]);
+    throw new GraphFormatError(
+      "E_INVALID_ID",
+      `${bad.length} node id${plural(bad.length)} cannot be written as ${format} integers (first: ${JSON.stringify(first)} at index ${bad[0]}); pass sanitizeIds: "mangle" to rewrite them`,
+      { reason: "charset", charset: "integer", count: bad.length, index: bad[0] }
+    );
+  }
+  const renumbered = /* @__PURE__ */ new Map();
+  let next = 0;
+  for (const i of bad) {
+    while (used.has(next)) {
+      next++;
+    }
+    used.add(next);
+    renumbered.set(i, next);
+  }
+  return {
+    changed: bad.length,
+    idAt: (i) => {
+      const id = renumbered.get(i) ?? ids.idOf(i);
+      return typeof id === "string" ? `${RAW}${id}` : id;
+    },
+    isChanged: (i) => renumbered.has(i),
+    originalAt: (i) => ids.idOf(i)
+  };
+}
+function nextNodeId(ids, count) {
+  let max = -1n;
+  for (let i = 0; i < count; i++) {
+    const id = ids.idAt(i);
+    const value = typeof id === "number" ? BigInt(id) : BigInt(id.slice(RAW.length));
+    if (value > max) {
+      max = value;
+    }
+  }
+  const next = max + 1n;
+  return next <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(next) : `${RAW}${next.toString()}`;
+}
+function unwritableIds(snapshot) {
+  let count = 0;
+  for (let i = 0; i < snapshot.ids.size; i++) {
+    if (!writableId(snapshot.ids.idOf(i))) {
+      count++;
+    }
+  }
+  return count;
+}
+function planNodeIds(snapshot, common, format, attribute, note) {
+  const unwritable = unwritableIds(snapshot);
+  if (unwritable > 0) {
+    note(
+      common.sanitizeIds === "mangle" ? LOSS.ID_MANGLED : LOSS.ID_CHARSET,
+      common.sanitizeIds === "mangle" ? `${unwritable} node id${plural(unwritable)} ${agree(unwritable, "is", "are")} not integers, so they are renumbered; the original ids are written to the ${attribute} attribute, and an import with restoreMangledIds: true reads them back` : `${unwritable} node id${plural(unwritable)} ${agree(unwritable, "is", "are")} not integers, so the save fails unless sanitizeIds is "mangle"`,
+      null,
+      unwritable
+    );
+  }
+  try {
+    return writtenIds(snapshot, common.sanitizeIds, format);
+  } catch (err) {
+    if (err instanceof GraphFormatError) {
+      return err;
+    }
+    throw err;
+  }
+}
+function scalarType(dtype, longOrigin) {
+  switch (dtype) {
+    case "f64":
+      return longOrigin ? "long" : "double";
+    case "f32":
+      return "double";
+    case "i32":
+    case "u8":
+      return "integer";
+    case "u32":
+      return "long";
+    case "bool":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+function allIntegral(column) {
+  for (let i = 0; i < column.length; i++) {
+    if (column.isSet(i) && !Number.isSafeInteger(column.value(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+function declaredType(column) {
+  const { meta } = column;
+  const origin = meta.origin?.type ?? null;
+  const longOrigin = origin !== null && origin.endsWith("long") && (meta.dtype !== "f64" || allIntegral(column));
+  if (meta.dtype === "list") {
+    return meta.itemDtype === null || meta.itemDtype === "json" ? "string" : `list_of_${scalarType(meta.itemDtype, longOrigin)}`;
+  }
+  return meta.components > 1 ? `list_of_${scalarType(meta.dtype, false)}` : scalarType(meta.dtype, longOrigin);
+}
+function nonFinitePositions(position) {
+  let count = 0;
+  for (let i = 0; i < position.length; i++) {
+    if (position.isSet(i)) {
+      const p = position.value(i);
+      if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) {
+        count++;
+      }
+    }
+  }
+  return count;
+}
+function planEdgeIds(snapshot, note, nodeIds = null) {
+  const column = snapshot.edges.byRole("id");
+  const used = /* @__PURE__ */ new Set();
+  let generated = 0;
+  const ids = keptEdgeIds(column, snapshot.edgeCount, used);
+  for (let i = 0; nodeIds !== null && i < snapshot.nodeCount; i++) {
+    const id = nodeIds.idAt(i);
+    if (typeof id === "number") {
+      used.add(id);
+    }
+  }
+  let next = 0;
+  const out = [];
+  for (let e = 0; e < snapshot.edgeCount; e++) {
+    let id = ids[e];
+    if (id === null) {
+      while (used.has(next)) {
+        next++;
+      }
+      id = next;
+      used.add(next);
+      generated++;
+    }
+    out.push(id);
+  }
+  if (column !== null && generated > 0) {
+    note(
+      LOSS.EDGE_IDS_GENERATED,
+      `${generated} edge${plural(generated)} ${agree(generated, "has", "have")} no distinct integer id in "${column.meta.name}"; they are written with generated ids`,
+      column.meta.name,
+      generated
+    );
+  }
+  if (column !== null && column.dtype !== "f64") {
+    note(
+      LOSS.DTYPE,
+      `edge id column "${column.meta.name}" is ${column.dtype}; CX edge ids are integers and read back as f64`,
+      column.meta.name,
+      snapshot.edgeCount - column.nullCount
+    );
+  }
+  return out;
+}
+function keptEdgeIds(column, edgeCount, used) {
+  const ids = new Array(edgeCount).fill(null);
+  if (column === null) {
+    return ids;
+  }
+  for (let e = 0; e < edgeCount; e++) {
+    const value = column.isSet(e) ? column.value(e) : void 0;
+    const n = typeof value === "number" || typeof value === "string" ? Number(value) : Number.NaN;
+    if (Number.isSafeInteger(n) && !used.has(n)) {
+      ids[e] = n === 0 ? 0 : n;
+      used.add(n);
+    }
+  }
+  return ids;
+}
+function directionNotes(snapshot, folding, common, undirectedCode, note) {
+  if (!snapshot.directed) {
+    note(
+      undirectedCode,
+      `the snapshot is undirected; every edge is written as a directed edge (${snapshot.edgeCount} edge${plural(snapshot.edgeCount)})`,
+      null,
+      snapshot.edgeCount
+    );
+  } else if (common.onMixedDirection !== "error") {
+    let undirected = 0;
+    for (let e = 0; e < snapshot.edgeCount; e++) {
+      if (!folding.folded(e) && !folding.sourceDirected(e)) {
+        undirected++;
+      }
+    }
+    if (undirected > 0) {
+      note(
+        undirectedCode,
+        `${undirected} undirected edge${plural(undirected)} ${agree(undirected, "is", "are")} written as one directed edge each (a pair folded to its primary); CX has no undirected edge`,
+        null,
+        undirected
+      );
+    }
+  }
+  if (folding.mutualCount > 0) {
+    note(
+      LOSS.MUTUAL_EXPANDED,
+      `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, "is", "are")} written as two directed edges; the mutual mark is lost`,
+      null,
+      folding.mutualCount
+    );
+  }
+}
+function noteList() {
+  const notes = [];
+  const note = (code, message, column = null, count = null) => {
+    notes.push(Object.freeze({ code, message, column, count }));
+  };
+  return { notes, note };
+}
+function stringify(value) {
+  const text = JSON.stringify(value, (_key, v) => Object.is(v, -0) ? `${RAW}-0` : v);
+  return text.includes(String.raw`\u0000cx:`) ? text.replaceAll(RAW_JSON, "$1") : text;
+}
+function* aspectBlock(aspect, elements) {
+  yield `{${JSON.stringify(aspect)}:[`;
+  let first = true;
+  for (const element of elements) {
+    yield first ? `
+${element}` : `,
+${element}`;
+    first = false;
+  }
+  yield "]},\n";
+}
+export {
+  planEdgeIds as a,
+  aspectBlock as b,
+  declaredType as c,
+  directionNotes as d,
+  nextNodeId as e,
+  nonFinitePositions as f,
+  noteList as n,
+  planNodeIds as p,
+  stringify as s
+};
+//# sourceMappingURL=cx-export-BEeF6ymo.js.map

package/dist/chunks/cx-export-BEeF6ymo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cx-export-BEeF6ymo.js","sources":["../../src/common/cx-export.ts"],"sourcesContent":["/**\n * The exporter machinery CX version 1 and CX2 share (design/graph-io/cytoscape-and-obo/design.md\n * sections 1.2 and 1.3): integer node ids (safe integers, or the digits of an integer beyond 2^53\n * written raw), sanitizeIds \"mangle\" renumbering, edge ids from the id role column, the declared\n * type of a column, the direction notes (every CX edge is directed) and the JSON writer that keeps\n * -0 and raw big integers.\n */\n\nimport { type Column, GraphFormatError, type GraphSnapshot, type NodeId } from \"@graphty/graph-format\";\n\nimport { type LossNote } from \"../types.js\";\nimport { type PairFolding } from \"./direction.js\";\nimport { LOSS } from \"./export.js\";\nimport { type ResolvedExportOptions } from \"./options.js\";\nimport { agree, plural } from \"./plural.js\";\n\n/**\n * Records a loss note.\n * @category Plugin helpers\n */\nexport type CxNoteFn = (code: string, message: string, column?: string | null, count?: number | null) => void;\n\n/**\n * The prefix of a string that stands for a raw number literal in the output: -0 (which\n * JSON.stringify writes as 0) and an integer id beyond 2^53 (kept as its digits).\n */\nconst RAW = `${String.fromCodePoint(0)}cx:`;\n\n/** A raw literal as JSON.stringify writes it, to be unquoted. */\nconst RAW_JSON = /\"\\\\u0000cx:(-?\\d+)\"/g;\n\n/** An integer literal beyond 2^53 as text: a CX id graph-io keeps as its digits. */\nconst BIG_INTEGER_TEXT = /^-?[1-9]\\d{15,}$/;\n\n/**\n * The node ids as written: the original, a renumbered one, or a raw big integer.\n * @category Plugin helpers\n */\nexport interface WrittenIds {\n    /** How many ids were renumbered (sanitizeIds \"mangle\"). */\n    readonly changed: number;\n    /**\n     * The written id of a node.\n     * @param i - the node index\n     * @returns a number, or a raw string for a big integer\n     */\n    idAt(i: number): NodeId;\n    /**\n     * Whether a node was renumbered.\n     * @param i - the node index\n     * @returns true when its original goes into graphty:originalId\n     */\n    isChanged(i: number): boolean;\n    /**\n     * The original id of a node.\n     * @param i - the node index\n     * @returns the snapshot's id\n     */\n    originalAt(i: number): NodeId;\n}\n\n/**\n * Whether an id can be written as a CX id unchanged: a safe integer, or the digits of an integer\n * beyond 2^53 (the CX importers read those back as the same digits).\n * @param id - the id\n * @returns true when writable\n */\nfunction writableId(id: NodeId): boolean {\n    return typeof id === \"number\"\n        ? Number.isSafeInteger(id)\n        : BIG_INTEGER_TEXT.test(id) && !Number.isSafeInteger(Number(id));\n}\n\n/**\n * The written node ids; under \"error\" an id that is not writable throws E_INVALID_ID, under\n * \"mangle\" it gets the next unused integer.\n * @param snapshot - the snapshot\n * @param mode - the sanitizeIds option\n * @param format - the format's display name, for the message\n * @returns the ids\n */\nfunction writtenIds(snapshot: GraphSnapshot, mode: \"error\" | \"mangle\", format: string): WrittenIds {\n    const { ids } = snapshot;\n    const bad: number[] = [];\n    const used = new Set<number>();\n    for (let i = 0; i < ids.size; i++) {\n        const id = ids.idOf(i);\n        if (!writableId(id)) {\n            bad.push(i);\n        } else if (typeof id === \"number\") {\n            used.add(id);\n        }\n    }\n    if (bad.length > 0 && mode === \"error\") {\n        const first = ids.idOf(bad[0]);\n        throw new GraphFormatError(\n            \"E_INVALID_ID\",\n            `${bad.length} node id${plural(bad.length)} cannot be written as ${format} integers (first: ${JSON.stringify(first)} at index ${bad[0]}); pass sanitizeIds: \"mangle\" to rewrite them`,\n            { reason: \"charset\", charset: \"integer\", count: bad.length, index: bad[0] },\n        );\n    }\n    const renumbered = new Map<number, number>();\n    let next = 0;\n    for (const i of bad) {\n        while (used.has(next)) {\n            next++;\n        }\n        used.add(next);\n        renumbered.set(i, next);\n    }\n    return {\n        changed: bad.length,\n        idAt: (i: number): NodeId => {\n            const id = renumbered.get(i) ?? ids.idOf(i);\n            return typeof id === \"string\" ? `${RAW}${id}` : id;\n        },\n        isChanged: (i: number): boolean => renumbered.has(i),\n        originalAt: (i: number): NodeId => ids.idOf(i),\n    };\n}\n\n/**\n * The `idCounter` of the node ids as written (the largest id plus one, NDEx's next free id).\n * @param ids - the written ids\n * @param count - the node count\n * @returns the counter: a number, or a raw big integer for stringify()\n * @category Plugin helpers\n */\nexport function nextNodeId(ids: WrittenIds, count: number): NodeId {\n    let max = -1n;\n    for (let i = 0; i < count; i++) {\n        const id = ids.idAt(i);\n        const value = typeof id === \"number\" ? BigInt(id) : BigInt(id.slice(RAW.length));\n        if (value > max) {\n            max = value;\n        }\n    }\n    const next = max + 1n;\n    return next <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(next) : `${RAW}${next.toString()}`;\n}\n\n/**\n * How many node ids are not writable unchanged.\n * @param snapshot - the snapshot\n * @returns the count\n */\nfunction unwritableIds(snapshot: GraphSnapshot): number {\n    let count = 0;\n    for (let i = 0; i < snapshot.ids.size; i++) {\n        if (!writableId(snapshot.ids.idOf(i))) {\n            count++;\n        }\n    }\n    return count;\n}\n\n/**\n * The id notes and the written ids of a CX export: E_ID_CHARSET (export() throws) or\n * W_ID_MANGLED for the ids that are not integers.\n * @param snapshot - the snapshot\n * @param common - the resolved common options\n * @param format - the format's display name\n * @param attribute - the attribute the originals are kept in\n * @param note - records a note\n * @returns the ids, or the error export() throws\n * @category Plugin helpers\n */\nexport function planNodeIds(\n    snapshot: GraphSnapshot,\n    common: ResolvedExportOptions,\n    format: string,\n    attribute: string,\n    note: CxNoteFn,\n): WrittenIds | GraphFormatError {\n    const unwritable = unwritableIds(snapshot);\n    if (unwritable > 0) {\n        note(\n            common.sanitizeIds === \"mangle\" ? LOSS.ID_MANGLED : LOSS.ID_CHARSET,\n            common.sanitizeIds === \"mangle\"\n                ? `${unwritable} node id${plural(unwritable)} ${agree(unwritable, \"is\", \"are\")} not integers, so they are renumbered; the original ids are written to the ${attribute} attribute, and an import with restoreMangledIds: true reads them back`\n                : `${unwritable} node id${plural(unwritable)} ${agree(unwritable, \"is\", \"are\")} not integers, so the save fails unless sanitizeIds is \"mangle\"`,\n            null,\n            unwritable,\n        );\n    }\n    try {\n        return writtenIds(snapshot, common.sanitizeIds, format);\n    } catch (err) {\n        if (err instanceof GraphFormatError) {\n            return err;\n        }\n        throw err;\n    }\n}\n\n/**\n * The CX type of a scalar dtype.\n * @param dtype - the dtype\n * @param longOrigin - whether the source declared the column long\n * @returns the type text\n */\nfunction scalarType(dtype: string, longOrigin: boolean): string {\n    switch (dtype) {\n        case \"f64\":\n            return longOrigin ? \"long\" : \"double\";\n        case \"f32\":\n            return \"double\";\n        case \"i32\":\n        case \"u8\":\n            return \"integer\";\n        case \"u32\":\n            return \"long\";\n        case \"bool\":\n            return \"boolean\";\n        default:\n            return \"string\";\n    }\n}\n\n/**\n * Whether every set value of an f64 column is integral (so a declared long stays long).\n * @param column - the column\n * @returns true when every set value is a safe integer\n */\nfunction allIntegral(column: Column): boolean {\n    for (let i = 0; i < column.length; i++) {\n        if (column.isSet(i) && !Number.isSafeInteger(column.value(i))) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/**\n * The declared CX type of a column: string / double / long / integer / boolean or a list of one;\n * a json column (and a list of json items) is a string holding JSON text.\n * @param column - the column\n * @returns the type text\n * @category Plugin helpers\n */\nexport function declaredType(column: Column): string {\n    const { meta } = column;\n    const origin = meta.origin?.type ?? null;\n    const longOrigin = origin !== null && origin.endsWith(\"long\") && (meta.dtype !== \"f64\" || allIntegral(column));\n    if (meta.dtype === \"list\") {\n        return meta.itemDtype === null || meta.itemDtype === \"json\"\n            ? \"string\"\n            : `list_of_${scalarType(meta.itemDtype, longOrigin)}`;\n    }\n    // a multi-component column (a color, a 3D vector) is written as a list of its components\n    return meta.components > 1 ? `list_of_${scalarType(meta.dtype, false)}` : scalarType(meta.dtype, longOrigin);\n}\n\n/**\n * Count the positions with a non-finite x or y.\n * @param position - the position column\n * @returns the count\n * @category Plugin helpers\n */\nexport function nonFinitePositions(position: Column): number {\n    let count = 0;\n    for (let i = 0; i < position.length; i++) {\n        if (position.isSet(i)) {\n            const p = position.value(i) as ArrayLike<number>;\n            if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) {\n                count++;\n            }\n        }\n    }\n    return count;\n}\n\n/**\n * The edge ids to write: the id role column's values when they are distinct safe integers, next\n * unused integers for edges without one (W_EDGE_IDS_GENERATED). A generated id is never a\n * written node id either: CX keeps node and edge ids apart, but Cytoscape desktop numbers both\n * from one counter, and a reader with one id space (Cytoscape.js) would have to drop the edge's.\n * @param snapshot - the snapshot\n * @param note - records a note\n * @param nodeIds - the written node ids, which generated edge ids avoid\n * @returns one id per edge\n * @category Plugin helpers\n */\nexport function planEdgeIds(snapshot: GraphSnapshot, note: CxNoteFn, nodeIds: WrittenIds | null = null): number[] {\n    const column = snapshot.edges.byRole(\"id\");\n    const used = new Set<number>();\n    let generated = 0;\n    const ids: (number | null)[] = keptEdgeIds(column, snapshot.edgeCount, used);\n    for (let i = 0; nodeIds !== null && i < snapshot.nodeCount; i++) {\n        const id = nodeIds.idAt(i);\n        if (typeof id === \"number\") {\n            used.add(id);\n        }\n    }\n    let next = 0;\n    const out: number[] = [];\n    for (let e = 0; e < snapshot.edgeCount; e++) {\n        let id = ids[e];\n        if (id === null) {\n            while (used.has(next)) {\n                next++;\n            }\n            id = next;\n            used.add(next);\n            generated++;\n        }\n        out.push(id);\n    }\n    if (column !== null && generated > 0) {\n        note(\n            LOSS.EDGE_IDS_GENERATED,\n            `${generated} edge${plural(generated)} ${agree(generated, \"has\", \"have\")} no distinct integer id in \"${column.meta.name}\"; they are written with generated ids`,\n            column.meta.name,\n            generated,\n        );\n    }\n    if (column !== null && column.dtype !== \"f64\") {\n        note(\n            LOSS.DTYPE,\n            `edge id column \"${column.meta.name}\" is ${column.dtype}; CX edge ids are integers and read back as f64`,\n            column.meta.name,\n            snapshot.edgeCount - column.nullCount,\n        );\n    }\n    return out;\n}\n\n/**\n * The edge ids an id column can keep: its distinct safe integers (numbers, or text that reads as one).\n * @param column - the edge id column, or null\n * @param edgeCount - the number of edges\n * @param used - receives the kept ids\n * @returns the kept id per edge, null where it cannot be kept\n */\nfunction keptEdgeIds(column: Column | null, edgeCount: number, used: Set<number>): (number | null)[] {\n    const ids: (number | null)[] = new Array<number | null>(edgeCount).fill(null);\n    if (column === null) {\n        return ids;\n    }\n    for (let e = 0; e < edgeCount; e++) {\n        const value = column.isSet(e) ? column.value(e) : undefined;\n        const n = typeof value === \"number\" || typeof value === \"string\" ? Number(value) : Number.NaN;\n        if (Number.isSafeInteger(n) && !used.has(n)) {\n            ids[e] = n === 0 ? 0 : n;\n            used.add(n);\n        }\n    }\n    return ids;\n}\n\n/**\n * The direction notes: every CX edge is directed, so an undirected snapshot (or the undirected\n * pairs of a mixed one, folded under onMixedDirection) is written directed, and a mutual pair as\n * two edges without its mark.\n * @param snapshot - the snapshot\n * @param folding - the pair folding\n * @param common - the resolved common options\n * @param undirectedCode - the format's \"undirected written as directed\" code\n * @param note - records a note\n * @category Plugin helpers\n */\nexport function directionNotes(\n    snapshot: GraphSnapshot,\n    folding: PairFolding,\n    common: ResolvedExportOptions,\n    undirectedCode: string,\n    note: CxNoteFn,\n): void {\n    if (!snapshot.directed) {\n        note(\n            undirectedCode,\n            `the snapshot is undirected; every edge is written as a directed edge (${snapshot.edgeCount} edge${plural(snapshot.edgeCount)})`,\n            null,\n            snapshot.edgeCount,\n        );\n    } else if (common.onMixedDirection !== \"error\") {\n        let undirected = 0;\n        for (let e = 0; e < snapshot.edgeCount; e++) {\n            if (!folding.folded(e) && !folding.sourceDirected(e)) {\n                undirected++;\n            }\n        }\n        if (undirected > 0) {\n            note(\n                undirectedCode,\n                `${undirected} undirected edge${plural(undirected)} ${agree(undirected, \"is\", \"are\")} written as one directed edge each (a pair folded to its primary); CX has no undirected edge`,\n                null,\n                undirected,\n            );\n        }\n    }\n    if (folding.mutualCount > 0) {\n        note(\n            LOSS.MUTUAL_EXPANDED,\n            `${folding.mutualCount} mutual pair${plural(folding.mutualCount)} ${agree(folding.mutualCount, \"is\", \"are\")} written as two directed edges; the mutual mark is lost`,\n            null,\n            folding.mutualCount,\n        );\n    }\n}\n\n/**\n * The note recorder of a plan and its notes.\n * @returns the notes and the recorder\n * @category Plugin helpers\n */\nexport function noteList(): { notes: LossNote[]; note: CxNoteFn } {\n    const notes: LossNote[] = [];\n    const note: CxNoteFn = (code, message, column = null, count = null) => {\n        notes.push(Object.freeze({ code, message, column, count }));\n    };\n    return { notes, note };\n}\n\n/**\n * The JSON text of a value, keeping -0 and writing the raw big-integer ids of idAt() as numbers.\n * @param value - the value\n * @returns the text\n * @category Plugin helpers\n */\nexport function stringify(value: unknown): string {\n    const text = JSON.stringify(value, (_key, v: unknown) => (Object.is(v, -0) ? `${RAW}-0` : v));\n    return text.includes(String.raw`\\u0000cx:`) ? text.replaceAll(RAW_JSON, \"$1\") : text;\n}\n\n/**\n * The text of one aspect block, element by element.\n * @param aspect - the aspect name\n * @param elements - the JSON texts of its elements\n * @yields the block's text\n * @returns nothing\n */\nexport function* aspectBlock(aspect: string, elements: Iterable<string>): Generator<string, void, undefined> {\n    yield `{${JSON.stringify(aspect)}:[`;\n    let first = true;\n    for (const element of elements) {\n        yield first ? `\\n${element}` : `,\\n${element}`;\n        first = false;\n    }\n    yield \"]},\\n\";\n}\n"],"names":[],"mappings":"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"}

package/dist/chunks/descriptor-BJ-W0Jd-.js

@@ -0,0 +1,137 @@
+const DEPS_DEV_MAPPING = Object.freeze({
+  version: 1,
+  endpoint: "https://api.deps.dev",
+  load: "dependencies",
+  directed: true,
+  requests: {
+    dependencies: {
+      path: "/v3/systems/{system}/packages/{package}/versions/{version}:dependencies",
+      records: ".",
+      entity: "graph"
+    }
+  },
+  entities: {
+    graph: {
+      id: "nodes",
+      node: false,
+      edges: [
+        {
+          each: "edges[]",
+          from: "fromNode",
+          to: "toNode",
+          type: "depends_on",
+          entity: "package",
+          fields: { requirement: "requirement" }
+        }
+      ],
+      embedded: [{ at: "nodes[]", entity: "package" }]
+    },
+    package: {
+      id: "#",
+      fields: {
+        name: "versionKey.name",
+        version: "versionKey.version",
+        system: "versionKey.system",
+        relation: "relation"
+      }
+    }
+  }
+});
+const STRING_MAPPING = Object.freeze({
+  version: 1,
+  endpoint: "https://string-db.org",
+  load: "network",
+  directed: false,
+  requests: {
+    network: {
+      path: "/api/json/network",
+      query: { identifiers: "{identifiers}", species: "{species}", add_nodes: "{add_nodes}" },
+      records: ".",
+      entity: "interaction"
+    }
+  },
+  entities: {
+    interaction: {
+      id: "stringId_A",
+      node: false,
+      edges: [
+        {
+          from: "stringId_A",
+          to: "stringId_B",
+          type: "interacts_with",
+          entity: "protein-b",
+          fields: { score: "score" }
+        }
+      ],
+      embedded: [
+        { at: ".", entity: "protein-a" },
+        { at: ".", entity: "protein-b" }
+      ]
+    },
+    "protein-a": { id: "stringId_A", label: "protein", fields: { name: "preferredName_A" } },
+    "protein-b": { id: "stringId_B", label: "protein", fields: { name: "preferredName_B" } }
+  }
+});
+const REST_DESCRIPTOR = Object.freeze({
+  plainName: "REST API",
+  kind: "rest",
+  version: 1,
+  auth: ["bearer", "api-key"],
+  authRequired: "optional",
+  params: [{ name: "mapping", plainName: "Mapping", type: "text", required: true }],
+  samples: [
+    {
+      id: "string-tp53",
+      plainName: "STRING: TP53's functional partners",
+      params: { mapping: STRING_MAPPING, identifiers: "TP53", species: "9606", add_nodes: "20" },
+      endpoint: STRING_MAPPING.endpoint,
+      counts: { nodes: 21, edges: 113 }
+    },
+    {
+      id: "deps-dev-webpack",
+      plainName: "deps.dev: webpack 5.90.0",
+      params: { mapping: DEPS_DEV_MAPPING, system: "npm", package: "webpack", version: "5.90.0" },
+      endpoint: DEPS_DEV_MAPPING.endpoint,
+      counts: { nodes: 84, edges: 121 }
+    }
+  ]
+});
+const OPENALEX_DESCRIPTOR = Object.freeze({
+  plainName: "OpenAlex",
+  kind: "rest",
+  version: 1,
+  defaultEndpoint: "https://api.openalex.org",
+  auth: ["api-key"],
+  authRequired: "optional",
+  rateLimit: { requests: 10, perMs: 1e3 },
+  params: [
+    { name: "work", plainName: "Work", type: "string" },
+    { name: "author", plainName: "Author", type: "string" },
+    {
+      name: "graph",
+      plainName: "Graph",
+      type: "enum",
+      default: "citation",
+      values: [
+        { value: "citation", label: "Citations" },
+        { value: "coauthorship", label: "Co-authors" }
+      ]
+    },
+    { name: "include", plainName: "Include", type: "string", advanced: true }
+  ],
+  samples: [
+    {
+      id: "openalex-watts-strogatz",
+      plainName: "Watts-Strogatz paper's citations",
+      params: { work: "W2112090702" },
+      whole: false
+    }
+  ]
+});
+export {
+  DEPS_DEV_MAPPING as D,
+  OPENALEX_DESCRIPTOR as O,
+  REST_DESCRIPTOR as R,
+  STRING_MAPPING as S
+};
+//# sourceMappingURL=descriptor-BJ-W0Jd-.js.map

package/dist/chunks/descriptor-BJ-W0Jd-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-BJ-W0Jd-.js","sources":["../../src/sources/rest/samples/deps-dev.ts","../../src/sources/rest/samples/string.ts","../../src/sources/rest/descriptor.ts"],"sourcesContent":["/**\n * A sample mapping: the resolved dependency graph of one package version from deps.dev\n * (https://deps.dev). The body already holds a node array and an edge array whose ends are node\n * positions, so the body is a container and `#` gives each package its position as its id.\n * Catalog data for the `rest` source's samples.\n */\n\nimport { type RestMapping } from \"../params.js\";\n\n/** The deps.dev dependencies mapping: `system` (npm, pypi, ...), `package` and `version`. */\nexport const DEPS_DEV_MAPPING: RestMapping = Object.freeze<RestMapping>({\n    version: 1,\n    endpoint: \"https://api.deps.dev\",\n    load: \"dependencies\",\n    directed: true,\n    requests: {\n        dependencies: {\n            path: \"/v3/systems/{system}/packages/{package}/versions/{version}:dependencies\",\n            records: \".\",\n            entity: \"graph\",\n        },\n    },\n    entities: {\n        graph: {\n            id: \"nodes\",\n            node: false,\n            edges: [\n                {\n                    each: \"edges[]\",\n                    from: \"fromNode\",\n                    to: \"toNode\",\n                    type: \"depends_on\",\n                    entity: \"package\",\n                    fields: { requirement: \"requirement\" },\n                },\n            ],\n            embedded: [{ at: \"nodes[]\", entity: \"package\" }],\n        },\n        package: {\n            id: \"#\",\n            fields: {\n                name: \"versionKey.name\",\n                version: \"versionKey.version\",\n                system: \"versionKey.system\",\n                relation: \"relation\",\n            },\n        },\n    },\n});\n","/**\n * A sample mapping: STRING's functional partners of a protein (https://string-db.org). Each\n * interaction record names both proteins, so both are embedded nodes and the record itself is only\n * the edge. Catalog data for the `rest` source's samples.\n */\n\nimport { type RestMapping } from \"../params.js\";\n\n/** The STRING network mapping: `identifiers`, `species` (NCBI taxon) and `add_nodes`. */\nexport const STRING_MAPPING: RestMapping = Object.freeze<RestMapping>({\n    version: 1,\n    endpoint: \"https://string-db.org\",\n    load: \"network\",\n    directed: false,\n    requests: {\n        network: {\n            path: \"/api/json/network\",\n            query: { identifiers: \"{identifiers}\", species: \"{species}\", add_nodes: \"{add_nodes}\" },\n            records: \".\",\n            entity: \"interaction\",\n        },\n    },\n    entities: {\n        interaction: {\n            id: \"stringId_A\",\n            node: false,\n            edges: [\n                {\n                    from: \"stringId_A\",\n                    to: \"stringId_B\",\n                    type: \"interacts_with\",\n                    entity: \"protein-b\",\n                    fields: { score: \"score\" },\n                },\n            ],\n            embedded: [\n                { at: \".\", entity: \"protein-a\" },\n                { at: \".\", entity: \"protein-b\" },\n            ],\n        },\n        \"protein-a\": { id: \"stringId_A\", label: \"protein\", fields: { name: \"preferredName_A\" } },\n        \"protein-b\": { id: \"stringId_B\", label: \"protein\", fields: { name: \"preferredName_B\" } },\n    },\n});\n","/**\n * The descriptors of the REST mapping source and its `openalex` preset: catalog data, available\n * without loading the sources' code.\n */\n\nimport { type SourceDescriptor } from \"../types.js\";\nimport { DEPS_DEV_MAPPING } from \"./samples/deps-dev.js\";\nimport { STRING_MAPPING } from \"./samples/string.js\";\n\n/**\n * The descriptor of the generic `rest` source. Experimental.\n * @category Network sources\n */\nexport const REST_DESCRIPTOR: SourceDescriptor = Object.freeze({\n    plainName: \"REST API\",\n    kind: \"rest\",\n    version: 1,\n    auth: [\"bearer\", \"api-key\"],\n    authRequired: \"optional\",\n    params: [{ name: \"mapping\", plainName: \"Mapping\", type: \"text\", required: true }],\n    samples: [\n        {\n            id: \"string-tp53\",\n            plainName: \"STRING: TP53's functional partners\",\n            params: { mapping: STRING_MAPPING, identifiers: \"TP53\", species: \"9606\", add_nodes: \"20\" },\n            endpoint: STRING_MAPPING.endpoint,\n            counts: { nodes: 21, edges: 113 },\n        },\n        {\n            id: \"deps-dev-webpack\",\n            plainName: \"deps.dev: webpack 5.90.0\",\n            params: { mapping: DEPS_DEV_MAPPING, system: \"npm\", package: \"webpack\", version: \"5.90.0\" },\n            endpoint: DEPS_DEV_MAPPING.endpoint,\n            counts: { nodes: 84, edges: 121 },\n        },\n    ],\n});\n\n/**\n * The descriptor of the `openalex` preset. Experimental.\n * @category Network sources\n */\nexport const OPENALEX_DESCRIPTOR: SourceDescriptor = Object.freeze({\n    plainName: \"OpenAlex\",\n    kind: \"rest\",\n    version: 1,\n    defaultEndpoint: \"https://api.openalex.org\",\n    auth: [\"api-key\"],\n    authRequired: \"optional\",\n    rateLimit: { requests: 10, perMs: 1000 },\n    params: [\n        { name: \"work\", plainName: \"Work\", type: \"string\" },\n        { name: \"author\", plainName: \"Author\", type: \"string\" },\n        {\n            name: \"graph\",\n            plainName: \"Graph\",\n            type: \"enum\",\n            default: \"citation\",\n            values: [\n                { value: \"citation\", label: \"Citations\" },\n                { value: \"coauthorship\", label: \"Co-authors\" },\n            ],\n        },\n        { name: \"include\", plainName: \"Include\", type: \"string\", advanced: true },\n    ],\n    samples: [\n        {\n            id: \"openalex-watts-strogatz\",\n            plainName: \"Watts-Strogatz paper's citations\",\n            params: { work: \"W2112090702\" },\n            whole: false,\n        },\n    ],\n});\n"],"names":[],"mappings":"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"}

package/dist/chunks/descriptor-C-YDhtsn.js

@@ -0,0 +1,48 @@
+function sample(id, plainName, uuid, nodes, edges) {
+  return { id, plainName, params: { uuid }, counts: { nodes, edges } };
+}
+const NDEX_DESCRIPTOR = Object.freeze({
+  plainName: "NDEx",
+  kind: "repository",
+  version: 1,
+  defaultEndpoint: "https://www.ndexbio.org/",
+  auth: ["basic", "bearer", "api-key"],
+  authRequired: "optional",
+  rateLimit: { requests: 50, perMs: 1e3, concurrent: 4 },
+  params: [
+    { name: "uuid", plainName: "Network UUID", type: "string", required: true },
+    {
+      name: "format",
+      plainName: "Format",
+      type: "enum",
+      default: "cx2",
+      advanced: true,
+      values: [
+        { value: "cx2", label: "CX2" },
+        { value: "cx", label: "CX" }
+      ]
+    },
+    { name: "idAttribute", plainName: "Id attribute", type: "string", advanced: true }
+  ],
+  features: ["probe", "list", "expand", "validate"],
+  samples: [
+    sample("ndex-wp5483", "WikiPathways WP5483", "86719f5b-1439-11f0-9806-005056ae3c32", 57, 34),
+    sample("ndex-nci-pid", "NCI PID cancer signaling", "640e2cef-795d-11e8-a4bf-0ac135e8bacf", 2794, 25296),
+    sample("ndex-huri", "HuRI human interactome", "73bc2c06-5fb2-11e9-9f06-0ac135e8bacf", 8275, 52569),
+    sample("ndex-signor", "Signor", "523fff27-afe8-11e9-8bb4-0ac135e8bacf", 10339, 33381),
+    sample("ndex-dgidb", "DGIdb drugs and target genes", "7e5e64ff-f6cf-11ea-99da-0ac135e8bacf", 12100, 32814),
+    sample(
+      "ndex-wikipathways-landscape",
+      "WikiPathways landscape",
+      "2b3ed6af-5031-11eb-9e72-0ac135e8bacf",
+      32077,
+      74109
+    ),
+    // 3.3 million edges and a 690 MB download: offered for neighborhoods, and as a maxBytes test
+    { ...sample("ndex-pcnet", "PCNet 2.2", "8b4b54fa-e87d-11ee-9621-005056ae23aa", 18558, 3323928), whole: false }
+  ]
+});
+export {
+  NDEX_DESCRIPTOR as N
+};
+//# sourceMappingURL=descriptor-C-YDhtsn.js.map

package/dist/chunks/descriptor-C-YDhtsn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-C-YDhtsn.js","sources":["../../src/sources/ndex/descriptor.ts"],"sourcesContent":["/**\n * The NDEx source's descriptor: catalog data, available without loading the source's code.\n */\n\nimport { type SourceDescriptor, type SourceSample } from \"../types.js\";\n\n/**\n * One public NDEx network offered as a sample.\n * @param id - the sample id\n * @param plainName - its name\n * @param uuid - the network UUID\n * @param nodes - its node count\n * @param edges - its edge count\n * @returns the sample\n */\nfunction sample(id: string, plainName: string, uuid: string, nodes: number, edges: number): SourceSample {\n    return { id, plainName, params: { uuid }, counts: { nodes, edges } };\n}\n\n/**\n * The descriptor of the `ndex` source. Experimental.\n * @category Network sources\n */\nexport const NDEX_DESCRIPTOR: SourceDescriptor = Object.freeze({\n    plainName: \"NDEx\",\n    kind: \"repository\",\n    version: 1,\n    defaultEndpoint: \"https://www.ndexbio.org/\",\n    auth: [\"basic\", \"bearer\", \"api-key\"],\n    authRequired: \"optional\",\n    rateLimit: { requests: 50, perMs: 1000, concurrent: 4 },\n    params: [\n        { name: \"uuid\", plainName: \"Network UUID\", type: \"string\", required: true },\n        {\n            name: \"format\",\n            plainName: \"Format\",\n            type: \"enum\",\n            default: \"cx2\",\n            advanced: true,\n            values: [\n                { value: \"cx2\", label: \"CX2\" },\n                { value: \"cx\", label: \"CX\" },\n            ],\n        },\n        { name: \"idAttribute\", plainName: \"Id attribute\", type: \"string\", advanced: true },\n    ],\n    features: [\"probe\", \"list\", \"expand\", \"validate\"],\n    samples: [\n        sample(\"ndex-wp5483\", \"WikiPathways WP5483\", \"86719f5b-1439-11f0-9806-005056ae3c32\", 57, 34),\n        sample(\"ndex-nci-pid\", \"NCI PID cancer signaling\", \"640e2cef-795d-11e8-a4bf-0ac135e8bacf\", 2794, 25296),\n        sample(\"ndex-huri\", \"HuRI human interactome\", \"73bc2c06-5fb2-11e9-9f06-0ac135e8bacf\", 8275, 52569),\n        sample(\"ndex-signor\", \"Signor\", \"523fff27-afe8-11e9-8bb4-0ac135e8bacf\", 10339, 33381),\n        sample(\"ndex-dgidb\", \"DGIdb drugs and target genes\", \"7e5e64ff-f6cf-11ea-99da-0ac135e8bacf\", 12100, 32814),\n        sample(\n            \"ndex-wikipathways-landscape\",\n            \"WikiPathways landscape\",\n            \"2b3ed6af-5031-11eb-9e72-0ac135e8bacf\",\n            32077,\n            74109,\n        ),\n        // 3.3 million edges and a 690 MB download: offered for neighborhoods, and as a maxBytes test\n        { ...sample(\"ndex-pcnet\", \"PCNet 2.2\", \"8b4b54fa-e87d-11ee-9621-005056ae23aa\", 18558, 3323928), whole: false },\n    ],\n});\n"],"names":[],"mappings":"AAeA,SAAS,OAAO,IAAY,WAAmB,MAAc,OAAe,OAA6B;AACrG,SAAO,EAAE,IAAI,WAAW,QAAQ,EAAE,KAAA,GAAQ,QAAQ,EAAE,OAAO,QAAM;AACrE;AAMO,MAAM,kBAAoC,OAAO,OAAO;AAAA,EAC3D,WAAW;AAAA,EACX,MAAM;AAAA,EACN,SAAS;AAAA,EACT,iBAAiB;AAAA,EACjB,MAAM,CAAC,SAAS,UAAU,SAAS;AAAA,EACnC,cAAc;AAAA,EACd,WAAW,EAAE,UAAU,IAAI,OAAO,KAAM,YAAY,EAAA;AAAA,EACpD,QAAQ;AAAA,IACJ,EAAE,MAAM,QAAQ,WAAW,gBAAgB,MAAM,UAAU,UAAU,KAAA;AAAA,IACrE;AAAA,MACI,MAAM;AAAA,MACN,WAAW;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,UAAU;AAAA,MACV,QAAQ;AAAA,QACJ,EAAE,OAAO,OAAO,OAAO,MAAA;AAAA,QACvB,EAAE,OAAO,MAAM,OAAO,KAAA;AAAA,MAAK;AAAA,IAC/B;AAAA,IAEJ,EAAE,MAAM,eAAe,WAAW,gBAAgB,MAAM,UAAU,UAAU,KAAA;AAAA,EAAK;AAAA,EAErF,UAAU,CAAC,SAAS,QAAQ,UAAU,UAAU;AAAA,EAChD,SAAS;AAAA,IACL,OAAO,eAAe,uBAAuB,wCAAwC,IAAI,EAAE;AAAA,IAC3F,OAAO,gBAAgB,4BAA4B,wCAAwC,MAAM,KAAK;AAAA,IACtG,OAAO,aAAa,0BAA0B,wCAAwC,MAAM,KAAK;AAAA,IACjG,OAAO,eAAe,UAAU,wCAAwC,OAAO,KAAK;AAAA,IACpF,OAAO,cAAc,gCAAgC,wCAAwC,OAAO,KAAK;AAAA,IACzG;AAAA,MACI;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA;AAAA;AAAA,IAGJ,EAAE,GAAG,OAAO,cAAc,aAAa,wCAAwC,OAAO,OAAO,GAAG,OAAO,MAAA;AAAA,EAAM;AAErH,CAAC;"}