@robosystems/report-components 0.1.4 → 0.2.0

package/dist/adapters/index.d.ts

@@ -1,2 +1,2 @@
-export { b as CypherAdapterConfig, R as ReportAdapter, i as cypherAdapter, j as jsonldFileAdapter, p as parseJsonld, k as parseStore } from '../index-DDFpPfUd.js';
+export { b as CypherAdapterConfig, R as ReportAdapter, g as SecQuery, h as SecReportShell, i as SecSection, l as cypherAdapter, m as fetchSecReportShell, n as fetchSecSection, o as jsonldFileAdapter, p as mergeSecSections, q as parseJsonld, r as parseStore, s as parseStructureDefinition } from '../index-D6FzPTm5.js';
 import 'n3';

package/dist/adapters/index.js

@@ -1,3 +1,3 @@
-export { cypherAdapter, jsonldFileAdapter, parseJsonld, parseStore } from '../chunk-JTTICHPF.js';
+export { cypherAdapter, fetchSecReportShell, fetchSecSection, jsonldFileAdapter, mergeSecSections, parseJsonld, parseStore, parseStructureDefinition } from '../chunk-POSLHOTN.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/chunk-POSLHOTN.js

@@ -0,0 +1,564 @@
+import { DataFactory, Store, Parser } from 'n3';
+import jsonld from 'jsonld';
+
+// src/constants.ts
+var NS = {
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  rs: "https://robosystems.ai/vocab/",
+  rsgaap: "https://robosystems.ai/taxonomy/rs-gaap/v1/",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  xlink: "http://www.w3.org/1999/xlink#",
+  xbrli: "http://www.xbrl.org/2003/instance#",
+  link: "http://www.xbrl.org/2003/linkbase#",
+  iso4217: "http://www.xbrl.org/2003/iso4217#"
+};
+var IRI = {
+  type: NS.rdf + "type",
+  // rs: classes
+  Report: NS.rs + "Report",
+  Fact: NS.rs + "Fact",
+  InformationBlock: NS.rs + "InformationBlock",
+  Structure: NS.rs + "Structure",
+  Association: NS.rs + "Association",
+  Element: NS.rs + "Element",
+  Period: NS.rs + "Period",
+  Unit: NS.rs + "Unit",
+  Entity: NS.rs + "Entity",
+  // rs: predicates
+  element: NS.rs + "element",
+  period: NS.rs + "period",
+  unit: NS.rs + "unit",
+  entity: NS.rs + "entity",
+  factSet: NS.rs + "factSet",
+  numericValue: NS.rs + "numericValue",
+  decimals: NS.rs + "decimals",
+  blockType: NS.rs + "blockType",
+  associationType: NS.rs + "associationType",
+  hasAssociation: NS.rs + "hasAssociation",
+  roleUri: NS.rs + "roleUri",
+  structureName: NS.rs + "structureName",
+  abstract: NS.rs + "abstract",
+  monetary: NS.rs + "monetary",
+  legalName: NS.rs + "legalName",
+  country: NS.rs + "country",
+  // skos:
+  prefLabel: NS.skos + "prefLabel",
+  // xlink:
+  from: NS.xlink + "from",
+  to: NS.xlink + "to",
+  role: NS.xlink + "role",
+  // xbrli:
+  instant: NS.xbrli + "instant",
+  startDate: NS.xbrli + "startDate",
+  endDate: NS.xbrli + "endDate",
+  periodType: NS.xbrli + "periodType",
+  balance: NS.xbrli + "balance",
+  measure: NS.xbrli + "measure",
+  // link:
+  order: NS.link + "order",
+  weight: NS.link + "weight"
+};
+var PREFIXES = [
+  ["rs-gaap", NS.rsgaap],
+  ["disclosures", "https://robosystems.ai/taxonomy/rs-gaap/disclosures/v1/"],
+  ["us-gaap", "http://fasb.org/us-gaap/"],
+  ["dei", "http://xbrl.sec.gov/dei/"],
+  ["rs", NS.rs],
+  ["skos", NS.skos],
+  ["xbrli", NS.xbrli],
+  ["xlink", NS.xlink],
+  ["link", NS.link],
+  ["iso4217", NS.iso4217]
+];
+function qname(iri) {
+  for (const [prefix, ns] of PREFIXES) {
+    if (iri.startsWith(ns)) {
+      return `${prefix}:${iri.slice(ns.length)}`;
+    }
+  }
+  const slash = iri.lastIndexOf("/");
+  const hash = iri.lastIndexOf("#");
+  return iri.slice(Math.max(slash, hash) + 1);
+}
+function humanize(iri) {
+  const local = qname(iri).split(":").pop() ?? iri;
+  return local.replace(/(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g, " ");
+}
+function isExternalFactUrl(value) {
+  return !!value && /^https?:\/\/\S+\/fact_[0-9a-f]+\.(html|txt)$/i.test(value);
+}
+var BLOCK_ORDER = {
+  balance_sheet: 0,
+  income_statement: 1,
+  cash_flow_statement: 2,
+  equity_statement: 3
+};
+var BLOCK_TITLES = {
+  balance_sheet: "Balance Sheet",
+  income_statement: "Income Statement",
+  cash_flow_statement: "Cash Flow Statement",
+  equity_statement: "Statement of Changes in Equity"
+};
+
+// src/adapters/sec.ts
+var ENTITY_META_Q = `
+MATCH (ent:Entity)-[:ENTITY_HAS_REPORT]->(r:Report {identifier: $rid})
+RETURN ent.identifier AS entity_id, ent.name AS entity_name,
+       ent.legal_name AS legal_name, ent.cik AS cik, ent.ticker AS ticker,
+       r.form AS form, r.report_date AS report_date`;
+var SECTIONS_Q = `
+MATCH (r:Report {identifier: $rid})-[:REPORT_HAS_FACT]->(f:Fact {has_dimensions: false})<-[:FACT_SET_CONTAINS_FACT]-(fs:FactSet)<-[:STRUCTURE_HAS_FACT_SET]-(s:Structure)
+RETURN s.identifier AS sid, s.canonical_type AS canonical_type,
+       s.definition AS definition, s.number AS number,
+       collect(DISTINCT fs.identifier) AS factsets
+ORDER BY number`;
+var FACTS_Q = `
+MATCH (fs:FactSet {identifier: $fsid})-[:FACT_SET_CONTAINS_FACT]->(f:Fact {has_dimensions: false})-[:FACT_HAS_ELEMENT]->(e:Element),
+      (f)-[:FACT_HAS_PERIOD]->(p:Period)
+WHERE f.value IS NOT NULL
+RETURN f.identifier AS fid, e.qname AS qname, e.name AS ename, e.balance AS balance,
+       e.period_type AS e_period_type, e.is_abstract AS is_abstract, e.is_numeric AS is_numeric,
+       f.numeric_value AS numeric_value, f.value AS raw_value, f.decimals AS decimals,
+       p.identifier AS pid, p.period_type AS period_type,
+       p.start_date AS start_date, p.end_date AS end_date
+LIMIT 2000`;
+var UNITS_Q = `
+MATCH (fs:FactSet {identifier: $fsid})-[:FACT_SET_CONTAINS_FACT]->(f:Fact {has_dimensions: false})-[:FACT_HAS_UNIT]->(u:Unit)
+WHERE f.value IS NOT NULL
+RETURN f.identifier AS fid, u.measure AS unit
+LIMIT 2000`;
+var ASSOC_Q = `
+MATCH (s:Structure {identifier: $sid})-[:STRUCTURE_HAS_ASSOCIATION]->(a:Association),
+      (a)-[:ASSOCIATION_HAS_FROM_ELEMENT]->(pe:Element),
+      (a)-[:ASSOCIATION_HAS_TO_ELEMENT]->(ce:Element)
+RETURN a.association_type AS association_type, a.order_value AS order_value,
+       a.weight AS weight, pe.qname AS parent, ce.qname AS child`;
+function str(row, key) {
+  const v = row[key];
+  return typeof v === "string" && v !== "" ? v : v == null ? null : String(v);
+}
+function num(row, key) {
+  const v = row[key];
+  if (v === null || v === void 0 || v === "") return null;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isNaN(n) ? null : n;
+}
+function bool(row, key) {
+  const v = row[key];
+  return v === true || v === "true";
+}
+function periodType(raw) {
+  return raw === "instant" || raw === "duration" ? raw : null;
+}
+var DENSE_PERIOD_FRACTION = 0.2;
+function filterToDominantPeriods(facts, periods) {
+  const countByEnd = /* @__PURE__ */ new Map();
+  for (const f of facts) {
+    const end = periods[f.period]?.end;
+    if (end) countByEnd.set(end, (countByEnd.get(end) ?? 0) + 1);
+  }
+  if (countByEnd.size <= 1) return facts;
+  const max = Math.max(...countByEnd.values());
+  const threshold = max * DENSE_PERIOD_FRACTION;
+  const keep = new Set(
+    [...countByEnd].filter(([, count]) => count >= threshold).map(([end]) => end)
+  );
+  return facts.filter((f) => {
+    const end = periods[f.period]?.end;
+    return end !== void 0 && keep.has(end);
+  });
+}
+var CORE_STATEMENT_TYPES = /* @__PURE__ */ new Set([
+  "balance_sheet",
+  "income_statement",
+  "cash_flow_statement",
+  "equity_statement",
+  "comprehensive_income"
+]);
+function parseStructureDefinition(definition, canonicalType) {
+  const raw = (definition ?? "").trim();
+  const parts = raw.split(" - ");
+  let type = "";
+  let title = raw;
+  if (parts.length >= 3) {
+    type = parts[1].trim();
+    title = parts.slice(2).join(" - ").trim();
+  } else if (parts.length === 2) {
+    title = parts[1].trim();
+  }
+  let kind = "Other";
+  if (/cover/i.test(title)) kind = "Cover";
+  else if (type === "Statement") kind = "Statement";
+  else if (type === "Disclosure") kind = "Disclosure";
+  else if (type === "Document") kind = "Document";
+  if (canonicalType && CORE_STATEMENT_TYPES.has(canonicalType)) kind = "Statement";
+  return { title: title || raw || canonicalType || "Section", kind };
+}
+function mapEntity(row) {
+  if (!row) return null;
+  const id = str(row, "entity_id");
+  if (!id) return null;
+  return {
+    id,
+    name: str(row, "entity_name") ?? str(row, "legal_name") ?? "Entity",
+    legalName: str(row, "legal_name"),
+    country: null
+  };
+}
+async function fetchSecReportShell(query, reportId) {
+  const [entityRows, sectionRows] = await Promise.all([
+    query(ENTITY_META_Q, { rid: reportId }),
+    query(SECTIONS_Q, { rid: reportId })
+  ]);
+  const sections = sectionRows.map((row, order) => {
+    const { title, kind } = parseStructureDefinition(
+      str(row, "definition"),
+      str(row, "canonical_type")
+    );
+    const factsets = Array.isArray(row.factsets) ? row.factsets.filter((v) => typeof v === "string") : [];
+    return {
+      id: str(row, "sid") ?? "",
+      title,
+      kind,
+      canonicalType: str(row, "canonical_type"),
+      order,
+      factsetIds: factsets
+    };
+  }).filter((s) => s.id && s.factsetIds.length > 0);
+  return { reportId, entity: mapEntity(entityRows[0]), sections };
+}
+function accumulateElement(elements, row) {
+  const q = str(row, "qname");
+  if (!q || elements[q]) return;
+  const balance = str(row, "balance");
+  elements[q] = {
+    id: q,
+    qname: q,
+    label: str(row, "ename") ? humanize(str(row, "ename")) : humanize(q),
+    balance: balance === "debit" || balance === "credit" ? balance : null,
+    periodType: periodType(str(row, "e_period_type")),
+    abstract: bool(row, "is_abstract"),
+    monetary: bool(row, "is_numeric")
+  };
+}
+function accumulatePeriod(periods, row) {
+  const id = str(row, "pid");
+  if (!id || periods[id]) return;
+  const type = periodType(str(row, "period_type")) ?? "duration";
+  const startDate = str(row, "start_date");
+  const endDate = str(row, "end_date");
+  periods[id] = {
+    id,
+    type,
+    instant: type === "instant" ? endDate : null,
+    startDate,
+    endDate,
+    end: endDate ?? ""
+  };
+}
+async function fetchSecSection(query, shell, section) {
+  const [factRowGroups, unitRowGroups, assocRows] = await Promise.all([
+    Promise.all(section.factsetIds.map((fsid) => query(FACTS_Q, { fsid }))),
+    Promise.all(section.factsetIds.map((fsid) => query(UNITS_Q, { fsid }))),
+    query(ASSOC_Q, { sid: section.id })
+  ]);
+  const unitByFid = /* @__PURE__ */ new Map();
+  for (const row of unitRowGroups.flat()) {
+    const fid = str(row, "fid");
+    const measure = str(row, "unit");
+    if (fid && measure) unitByFid.set(fid, measure);
+  }
+  const elements = {};
+  const periods = {};
+  const units = {};
+  const facts = [];
+  const seenFacts = /* @__PURE__ */ new Set();
+  for (const row of factRowGroups.flat()) {
+    const fid = str(row, "fid");
+    const element = str(row, "qname");
+    const period = str(row, "pid");
+    if (!fid || !element || !period || seenFacts.has(fid)) continue;
+    seenFacts.add(fid);
+    accumulateElement(elements, row);
+    accumulatePeriod(periods, row);
+    const measure = unitByFid.get(fid) ?? null;
+    if (measure && !units[measure]) {
+      const compact = qname(measure);
+      units[measure] = {
+        id: measure,
+        measure: compact,
+        label: compact.includes(":") ? compact.split(":").pop() : compact
+      };
+    }
+    const value = num(row, "numeric_value");
+    facts.push({
+      id: fid,
+      element,
+      period,
+      unit: measure,
+      entity: shell.entity?.id ?? null,
+      factSet: section.id,
+      value,
+      decimals: str(row, "decimals"),
+      textValue: value === null ? str(row, "raw_value") : null
+    });
+  }
+  const calcAssociations = [];
+  const presAssociations = [];
+  for (const row of assocRows) {
+    const parent = str(row, "parent");
+    const child = str(row, "child");
+    if (!parent || !child) continue;
+    const order = num(row, "order_value") ?? 0;
+    const type = str(row, "association_type")?.toLowerCase();
+    if (type === "calculation") {
+      calcAssociations.push({
+        parent,
+        child,
+        weight: num(row, "weight") ?? 1,
+        order,
+        role: null,
+        structure: section.id
+      });
+    } else if (type === "presentation") {
+      presAssociations.push({ parent, child, order, role: null, structure: section.id });
+    }
+  }
+  const informationBlock = {
+    id: section.id,
+    blockType: section.canonicalType ?? "",
+    factSet: section.id,
+    label: section.title,
+    structureId: section.id
+  };
+  const structure = {
+    id: section.id,
+    blockType: section.canonicalType ?? "",
+    roleUri: null,
+    structureName: section.title,
+    order: section.order
+  };
+  return {
+    reportId: shell.reportId,
+    reportIri: null,
+    entity: shell.entity,
+    informationBlocks: [informationBlock],
+    structures: [structure],
+    facts: filterToDominantPeriods(facts, periods),
+    elements,
+    periods,
+    units,
+    calcAssociations,
+    presAssociations
+  };
+}
+function mergeSecSections(shell, sections) {
+  const elements = {};
+  const periods = {};
+  const units = {};
+  const informationBlocks = [];
+  const structures = [];
+  const facts = [];
+  const calcAssociations = [];
+  const presAssociations = [];
+  for (const part of sections) {
+    Object.assign(elements, part.elements);
+    Object.assign(periods, part.periods);
+    Object.assign(units, part.units);
+    informationBlocks.push(...part.informationBlocks);
+    structures.push(...part.structures);
+    facts.push(...part.facts);
+    calcAssociations.push(...part.calcAssociations);
+    presAssociations.push(...part.presAssociations);
+  }
+  return {
+    reportId: shell.reportId,
+    reportIri: null,
+    entity: shell.entity,
+    informationBlocks,
+    structures,
+    facts,
+    elements,
+    periods,
+    units,
+    calcAssociations,
+    presAssociations
+  };
+}
+
+// src/adapters/cypher.ts
+function cypherAdapter(config) {
+  return {
+    source: `sec:${config.reportId}`,
+    load: async () => {
+      const shell = await fetchSecReportShell(config.query, config.reportId);
+      const sections = await Promise.all(
+        shell.sections.map((section) => fetchSecSection(config.query, shell, section))
+      );
+      return mergeSecSections(shell, sections);
+    }
+  };
+}
+var { namedNode } = DataFactory;
+function makeReaders(store) {
+  const objects = (s, p) => store.getObjects(namedNode(s), namedNode(p), null);
+  const firstValue = (s, p) => {
+    const os = objects(s, p);
+    return os.length ? os[0].value : null;
+  };
+  const subjectsOfType = (type) => store.getSubjects(namedNode(IRI.type), namedNode(type), null).map((t) => t.value);
+  return { objects, firstValue, subjectsOfType };
+}
+function toNumber(raw) {
+  if (raw === null || raw === "") return null;
+  const n = Number(raw);
+  return Number.isNaN(n) ? null : n;
+}
+function parseStore(store) {
+  const { objects, firstValue, subjectsOfType } = makeReaders(store);
+  const elements = {};
+  for (const id of subjectsOfType(IRI.Element)) {
+    const balance = firstValue(id, IRI.balance);
+    const periodType2 = firstValue(id, IRI.periodType);
+    elements[id] = {
+      id,
+      qname: qname(id),
+      label: firstValue(id, IRI.prefLabel) ?? humanize(id),
+      balance: balance === "debit" || balance === "credit" ? balance : null,
+      periodType: periodType2 === "instant" || periodType2 === "duration" ? periodType2 : null,
+      abstract: firstValue(id, IRI.abstract) === "true",
+      monetary: firstValue(id, IRI.monetary) === "true"
+    };
+  }
+  const periods = {};
+  for (const id of subjectsOfType(IRI.Period)) {
+    const declared = firstValue(id, IRI.periodType);
+    const instant = firstValue(id, IRI.instant);
+    const startDate = firstValue(id, IRI.startDate);
+    const endDate = firstValue(id, IRI.endDate);
+    const type = declared === "instant" ? "instant" : declared === "duration" ? "duration" : instant ? "instant" : "duration";
+    const end = (type === "instant" ? instant : endDate) ?? instant ?? endDate ?? "";
+    periods[id] = { id, type, instant, startDate, endDate, end };
+  }
+  const units = {};
+  for (const id of subjectsOfType(IRI.Unit)) {
+    const measureTerm = objects(id, IRI.measure)[0];
+    const measure = measureTerm ? qname(measureTerm.value) : "unknown";
+    units[id] = {
+      id,
+      measure,
+      label: measure.includes(":") ? measure.split(":").pop() : measure
+    };
+  }
+  let entity = null;
+  const entityIds = subjectsOfType(IRI.Entity);
+  if (entityIds.length) {
+    const id = entityIds[0];
+    entity = {
+      id,
+      name: firstValue(id, IRI.prefLabel) ?? firstValue(id, IRI.legalName) ?? "Entity",
+      legalName: firstValue(id, IRI.legalName),
+      country: firstValue(id, IRI.country)
+    };
+  }
+  const facts = [];
+  for (const id of subjectsOfType(IRI.Fact)) {
+    facts.push({
+      id,
+      element: firstValue(id, IRI.element) ?? "",
+      period: firstValue(id, IRI.period) ?? "",
+      unit: firstValue(id, IRI.unit),
+      entity: firstValue(id, IRI.entity),
+      factSet: firstValue(id, IRI.factSet),
+      value: toNumber(firstValue(id, IRI.numericValue)),
+      decimals: firstValue(id, IRI.decimals)
+    });
+  }
+  const informationBlocks = [];
+  for (const id of subjectsOfType(IRI.InformationBlock)) {
+    informationBlocks.push({
+      id,
+      blockType: firstValue(id, IRI.blockType) ?? "",
+      factSet: firstValue(id, IRI.factSet),
+      label: firstValue(id, IRI.prefLabel)
+    });
+  }
+  const structures = [];
+  const assocStructure = /* @__PURE__ */ new Map();
+  for (const id of subjectsOfType(IRI.Structure)) {
+    structures.push({
+      id,
+      blockType: firstValue(id, IRI.blockType) ?? "",
+      roleUri: firstValue(id, IRI.roleUri),
+      structureName: firstValue(id, IRI.structureName)
+    });
+    for (const assoc of objects(id, IRI.hasAssociation)) {
+      assocStructure.set(assoc.value, id);
+    }
+  }
+  const calcAssociations = [];
+  const presAssociations = [];
+  for (const id of subjectsOfType(IRI.Association)) {
+    const parent = firstValue(id, IRI.from);
+    const child = firstValue(id, IRI.to);
+    if (!parent || !child) continue;
+    const type = firstValue(id, IRI.associationType);
+    const order = toNumber(firstValue(id, IRI.order)) ?? 0;
+    const role = firstValue(id, IRI.role);
+    const structure = assocStructure.get(id) ?? null;
+    if (type === "calculation") {
+      calcAssociations.push({
+        parent,
+        child,
+        weight: toNumber(firstValue(id, IRI.weight)) ?? 1,
+        order,
+        role,
+        structure
+      });
+    } else if (type === "presentation") {
+      presAssociations.push({ parent, child, order, role, structure });
+    }
+  }
+  let reportIri = null;
+  for (const graph of store.getGraphs(null, null, null)) {
+    const hash = graph.value.indexOf("#");
+    if (hash > 0) {
+      reportIri = graph.value.slice(0, hash);
+      break;
+    }
+  }
+  if (!reportIri) {
+    const reports = subjectsOfType(IRI.Report);
+    reportIri = reports.length ? reports[0] : null;
+  }
+  const reportId = reportIri ? reportIri.split("/").pop() ?? null : null;
+  return {
+    reportId,
+    reportIri,
+    entity,
+    informationBlocks,
+    structures,
+    facts,
+    elements,
+    periods,
+    units,
+    calcAssociations,
+    presAssociations
+  };
+}
+async function parseJsonld(doc) {
+  const json = typeof doc === "string" ? JSON.parse(doc) : doc;
+  const nquads = await jsonld.toRDF(json, { format: "application/n-quads" });
+  const store = new Store(new Parser({ format: "application/n-quads" }).parse(nquads));
+  return parseStore(store);
+}
+function jsonldFileAdapter(doc, source = "holon.jsonld") {
+  return {
+    source,
+    load: () => parseJsonld(doc)
+  };
+}
+
+export { BLOCK_ORDER, BLOCK_TITLES, NS, cypherAdapter, fetchSecReportShell, fetchSecSection, humanize, isExternalFactUrl, jsonldFileAdapter, mergeSecSections, parseJsonld, parseStore, parseStructureDefinition, qname };
+//# sourceMappingURL=chunk-POSLHOTN.js.map
+//# sourceMappingURL=chunk-POSLHOTN.js.map