@flanksource/clicky-ui 0.3.21 → 0.3.23

package/dist/rpc/executionPages.js

@@ -0,0 +1,94 @@
+import { parseClickyData } from "../data/clicky-parse.js";
+function mergeExecutionPages(pages) {
+  const first = pages[0];
+  const last = pages[pages.length - 1];
+  if (!first || !last) return null;
+  if (pages.length === 1) return first;
+  const documents = pages.map(documentOf);
+  const base = documents[0];
+  if (!base || !findFirstTable(base.node)) return last;
+  const rows = [];
+  for (const [index, document] of documents.entries()) {
+    const table = document ? findFirstTable(document.node) : void 0;
+    if (!table) {
+      throw new Error(
+        `Cursor walk page ${index + 1} of ${pages.length} carries no table to append to the run`
+      );
+    }
+    rows.push(...table.rows ?? []);
+  }
+  const merged = {
+    version: 1,
+    node: mapFirstTable(base.node, (table) => ({ ...table, rows })).node
+  };
+  return {
+    ...last,
+    // The paging facts are the newest page's — how many rows exist and whether
+    // more follow are answers about now — but a download re-requests
+    // `requestUrl`, and the walk's identity is the request that named the query
+    // without naming a position inside it.
+    ...first.requestUrl !== void 0 ? { requestUrl: first.requestUrl } : {},
+    parsed: merged,
+    stdout: JSON.stringify(merged),
+    ...last.output !== void 0 ? { output: JSON.stringify(merged) } : {}
+  };
+}
+function documentOf(response) {
+  const payload = response.parsed ?? response.stdout ?? response.output ?? "";
+  if (typeof payload !== "string" && typeof payload !== "object") return void 0;
+  const parsed = parseClickyData(payload);
+  return parsed.ok ? parsed.document : void 0;
+}
+function findFirstTable(node) {
+  let found;
+  mapFirstTable(node, (table) => {
+    found = table;
+    return table;
+  });
+  return found;
+}
+function mapFirstTable(node, fn) {
+  if (node.kind === "table") return { node: fn(node), found: true };
+  const children = mapFirstIn(node.children, fn);
+  if (children) return { node: { ...node, children }, found: true };
+  const items = mapFirstIn(node.items, fn);
+  if (items) return { node: { ...node, items }, found: true };
+  if (node.fields) {
+    const values = mapFirstIn(
+      node.fields.map((field) => field.value),
+      fn
+    );
+    if (values) {
+      return {
+        node: {
+          ...node,
+          fields: node.fields.map((field, index) => ({
+            ...field,
+            value: values[index] ?? field.value
+          }))
+        },
+        found: true
+      };
+    }
+  }
+  if (node.content) {
+    const content = mapFirstTable(node.content, fn);
+    if (content.found) return { node: { ...node, content: content.node }, found: true };
+  }
+  return { node, found: false };
+}
+function mapFirstIn(nodes, fn) {
+  if (!nodes) return void 0;
+  for (const [index, child] of nodes.entries()) {
+    const mapped = mapFirstTable(child, fn);
+    if (!mapped.found) continue;
+    const next = [...nodes];
+    next[index] = mapped.node;
+    return next;
+  }
+  return void 0;
+}
+export {
+  mergeExecutionPages
+};
+//# sourceMappingURL=executionPages.js.map

package/dist/rpc/executionPages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executionPages.js","sources":["../../src/rpc/executionPages.ts"],"sourcesContent":["import type { ClickyDocument, ClickyNode, ClickyRow } from \"../data/Clicky\";\nimport { parseClickyData } from \"../data/clicky-parse\";\nimport type { ExecutionResponse } from \"./types\";\n\n/**\n * mergeExecutionPages stacks a cursor walk into the one document the default\n * result surface renders.\n *\n * The walk arrives unmerged because a page is a rendered document, not a row\n * array, and what stacking two of them means depends on what they contain. For\n * the clicky result surface the answer is knowable: the payload is a table, and\n * appending its rows in walk order is what \"one continuous list\" means. Every\n * other part of the document is the first page's, because the columns, the\n * headings and the shape are facts about the query rather than about the page.\n *\n * Callers hand over the whole walk on every render, so a single-page walk is\n * returned by identity — the common case must not churn the document and force\n * the table to rebuild rows nobody changed.\n */\nexport function mergeExecutionPages(\n  pages: readonly ExecutionResponse[],\n): ExecutionResponse | null {\n  const first = pages[0];\n  const last = pages[pages.length - 1];\n  if (!first || !last) return null;\n  if (pages.length === 1) return first;\n\n  const documents = pages.map(documentOf);\n  const base = documents[0];\n  // A walk whose pages are not tables has nothing to accumulate into — a\n  // detail document, say, served one at a time. The newest one is the whole of\n  // what there is to show.\n  if (!base || !findFirstTable(base.node)) return last;\n\n  const rows: ClickyRow[] = [];\n  for (const [index, document] of documents.entries()) {\n    const table = document ? findFirstTable(document.node) : undefined;\n    if (!table) {\n      // Loudly, because the alternative is deleting rows the reader has\n      // already scrolled past and calling it a shorter list.\n      throw new Error(\n        `Cursor walk page ${index + 1} of ${pages.length} carries no table to append to the run`,\n      );\n    }\n    rows.push(...(table.rows ?? []));\n  }\n\n  const merged: ClickyDocument = {\n    version: 1,\n    node: mapFirstTable(base.node, (table) => ({ ...table, rows })).node,\n  };\n\n  return {\n    ...last,\n    // The paging facts are the newest page's — how many rows exist and whether\n    // more follow are answers about now — but a download re-requests\n    // `requestUrl`, and the walk's identity is the request that named the query\n    // without naming a position inside it.\n    ...(first.requestUrl !== undefined ? { requestUrl: first.requestUrl } : {}),\n    parsed: merged,\n    stdout: JSON.stringify(merged),\n    ...(last.output !== undefined ? { output: JSON.stringify(merged) } : {}),\n  };\n}\n\n// The executor puts the decoded document on `parsed` and its bytes on\n// `stdout`; CommandOutput reads them in that order, so this does too or a\n// merged page could disagree with the one the renderer would have shown.\nfunction documentOf(response: ExecutionResponse): ClickyDocument | undefined {\n  const payload = response.parsed ?? response.stdout ?? response.output ?? \"\";\n  if (typeof payload !== \"string\" && typeof payload !== \"object\") return undefined;\n  const parsed = parseClickyData(payload as Parameters<typeof parseClickyData>[0]);\n  return parsed.ok ? parsed.document : undefined;\n}\n\nfunction findFirstTable(node: ClickyNode): ClickyNode | undefined {\n  let found: ClickyNode | undefined;\n  mapFirstTable(node, (table) => {\n    found = table;\n    return table;\n  });\n  return found;\n}\n\n/**\n * Rebuilds `node` with its first table — depth-first, in document order —\n * replaced by `fn`'s result. One traversal serves both finding a table and\n * rewriting it, so the page a walk reads rows out of is by construction the\n * page it writes them back into.\n */\nfunction mapFirstTable(\n  node: ClickyNode,\n  fn: (table: ClickyNode) => ClickyNode,\n): { node: ClickyNode; found: boolean } {\n  if (node.kind === \"table\") return { node: fn(node), found: true };\n\n  const children = mapFirstIn(node.children, fn);\n  if (children) return { node: { ...node, children }, found: true };\n\n  const items = mapFirstIn(node.items, fn);\n  if (items) return { node: { ...node, items }, found: true };\n\n  if (node.fields) {\n    const values = mapFirstIn(\n      node.fields.map((field) => field.value),\n      fn,\n    );\n    if (values) {\n      return {\n        node: {\n          ...node,\n          fields: node.fields.map((field, index) => ({\n            ...field,\n            value: values[index] ?? field.value,\n          })),\n        },\n        found: true,\n      };\n    }\n  }\n\n  if (node.content) {\n    const content = mapFirstTable(node.content, fn);\n    if (content.found) return { node: { ...node, content: content.node }, found: true };\n  }\n\n  return { node, found: false };\n}\n\n/** The rewritten list, or undefined when none of `nodes` held a table. */\nfunction mapFirstIn(\n  nodes: ClickyNode[] | undefined,\n  fn: (table: ClickyNode) => ClickyNode,\n): ClickyNode[] | undefined {\n  if (!nodes) return undefined;\n  for (const [index, child] of nodes.entries()) {\n    const mapped = mapFirstTable(child, fn);\n    if (!mapped.found) continue;\n    const next = [...nodes];\n    next[index] = mapped.node;\n    return next;\n  }\n  return undefined;\n}\n"],"names":[],"mappings":"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"}

package/dist/rpc/filterShapes.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function resolveFilterShape(param, components) {
+  var _a;
+  const ref = (_a = param["x-clicky-lookup"]) == null ? void 0 : _a.$ref;
+  if (!ref || !components) return void 0;
+  const name = ref.split("/").pop();
+  return name ? components[name] : void 0;
+}
+function filterShapesByName(parameters, components) {
+  return new Map(
+    parameters.map((param) => [param.name, resolveFilterShape(param, components)])
+  );
+}
+exports.filterShapesByName = filterShapesByName;
+exports.resolveFilterShape = resolveFilterShape;
+//# sourceMappingURL=filterShapes.cjs.map

package/dist/rpc/filterShapes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterShapes.cjs","sources":["../../src/rpc/filterShapes.ts"],"sourcesContent":["import type { ClickyFilterShape, OpenAPIParameter } from \"./types\";\n\n/**\n * Resolves a parameter's filter control shape from the spec's shared component\n * map, following the `$ref` the server stamped on it.\n *\n * A control's shape belongs to the spec, not to a lookup response: the spec is\n * fetched once and never varies with the values currently selected, so a filter\n * bar built from it renders the right control on first paint and holds it while\n * fresh options are in flight. A parameter that names no shape — a plain string\n * param — resolves to undefined and is rendered as the text input it is.\n *\n * A ref that does not resolve is treated the same as an absent one rather than\n * throwing: the spec is remote input, and one stale pointer should cost that\n * single control its chrome, not the whole bar.\n */\nexport function resolveFilterShape(\n  param: OpenAPIParameter,\n  components: Record<string, ClickyFilterShape> | undefined,\n): ClickyFilterShape | undefined {\n  const ref = param[\"x-clicky-lookup\"]?.$ref;\n  if (!ref || !components) return undefined;\n  const name = ref.split(\"/\").pop();\n  return name ? components[name] : undefined;\n}\n\n/**\n * Indexes every parameter's shape by name, so a caller that consults shapes\n * repeatedly resolves each ref once.\n */\nexport function filterShapesByName(\n  parameters: OpenAPIParameter[],\n  components: Record<string, ClickyFilterShape> | undefined,\n): Map<string, ClickyFilterShape | undefined> {\n  return new Map(\n    parameters.map((param) => [param.name, resolveFilterShape(param, components)]),\n  );\n}\n"],"names":[],"mappings":";;AAgBO,SAAS,mBACd,OACA,YAC+B;;AAC/B,QAAM,OAAM,WAAM,iBAAiB,MAAvB,mBAA0B;AACtC,MAAI,CAAC,OAAO,CAAC,WAAY,QAAO;AAChC,QAAM,OAAO,IAAI,MAAM,GAAG,EAAE,IAAA;AAC5B,SAAO,OAAO,WAAW,IAAI,IAAI;AACnC;AAMO,SAAS,mBACd,YACA,YAC4C;AAC5C,SAAO,IAAI;AAAA,IACT,WAAW,IAAI,CAAC,UAAU,CAAC,MAAM,MAAM,mBAAmB,OAAO,UAAU,CAAC,CAAC;AAAA,EAAA;AAEjF;;;"}

package/dist/rpc/filterShapes.d.ts

@@ -0,0 +1,22 @@
+import { ClickyFilterShape, OpenAPIParameter } from './types';
+/**
+ * Resolves a parameter's filter control shape from the spec's shared component
+ * map, following the `$ref` the server stamped on it.
+ *
+ * A control's shape belongs to the spec, not to a lookup response: the spec is
+ * fetched once and never varies with the values currently selected, so a filter
+ * bar built from it renders the right control on first paint and holds it while
+ * fresh options are in flight. A parameter that names no shape — a plain string
+ * param — resolves to undefined and is rendered as the text input it is.
+ *
+ * A ref that does not resolve is treated the same as an absent one rather than
+ * throwing: the spec is remote input, and one stale pointer should cost that
+ * single control its chrome, not the whole bar.
+ */
+export declare function resolveFilterShape(param: OpenAPIParameter, components: Record<string, ClickyFilterShape> | undefined): ClickyFilterShape | undefined;
+/**
+ * Indexes every parameter's shape by name, so a caller that consults shapes
+ * repeatedly resolves each ref once.
+ */
+export declare function filterShapesByName(parameters: OpenAPIParameter[], components: Record<string, ClickyFilterShape> | undefined): Map<string, ClickyFilterShape | undefined>;
+//# sourceMappingURL=filterShapes.d.ts.map

package/dist/rpc/filterShapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterShapes.d.ts","sourceRoot":"","sources":["../../src/rpc/filterShapes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAAS,GACxD,iBAAiB,GAAG,SAAS,CAK/B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,gBAAgB,EAAE,EAC9B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAAS,GACxD,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC,CAI5C"}

package/dist/rpc/filterShapes.js

@@ -0,0 +1,17 @@
+function resolveFilterShape(param, components) {
+  var _a;
+  const ref = (_a = param["x-clicky-lookup"]) == null ? void 0 : _a.$ref;
+  if (!ref || !components) return void 0;
+  const name = ref.split("/").pop();
+  return name ? components[name] : void 0;
+}
+function filterShapesByName(parameters, components) {
+  return new Map(
+    parameters.map((param) => [param.name, resolveFilterShape(param, components)])
+  );
+}
+export {
+  filterShapesByName,
+  resolveFilterShape
+};
+//# sourceMappingURL=filterShapes.js.map

package/dist/rpc/filterShapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterShapes.js","sources":["../../src/rpc/filterShapes.ts"],"sourcesContent":["import type { ClickyFilterShape, OpenAPIParameter } from \"./types\";\n\n/**\n * Resolves a parameter's filter control shape from the spec's shared component\n * map, following the `$ref` the server stamped on it.\n *\n * A control's shape belongs to the spec, not to a lookup response: the spec is\n * fetched once and never varies with the values currently selected, so a filter\n * bar built from it renders the right control on first paint and holds it while\n * fresh options are in flight. A parameter that names no shape — a plain string\n * param — resolves to undefined and is rendered as the text input it is.\n *\n * A ref that does not resolve is treated the same as an absent one rather than\n * throwing: the spec is remote input, and one stale pointer should cost that\n * single control its chrome, not the whole bar.\n */\nexport function resolveFilterShape(\n  param: OpenAPIParameter,\n  components: Record<string, ClickyFilterShape> | undefined,\n): ClickyFilterShape | undefined {\n  const ref = param[\"x-clicky-lookup\"]?.$ref;\n  if (!ref || !components) return undefined;\n  const name = ref.split(\"/\").pop();\n  return name ? components[name] : undefined;\n}\n\n/**\n * Indexes every parameter's shape by name, so a caller that consults shapes\n * repeatedly resolves each ref once.\n */\nexport function filterShapesByName(\n  parameters: OpenAPIParameter[],\n  components: Record<string, ClickyFilterShape> | undefined,\n): Map<string, ClickyFilterShape | undefined> {\n  return new Map(\n    parameters.map((param) => [param.name, resolveFilterShape(param, components)]),\n  );\n}\n"],"names":[],"mappings":"AAgBO,SAAS,mBACd,OACA,YAC+B;AAH1B;AAIL,QAAM,OAAM,WAAM,iBAAiB,MAAvB,mBAA0B;AACtC,MAAI,CAAC,OAAO,CAAC,WAAY,QAAO;AAChC,QAAM,OAAO,IAAI,MAAM,GAAG,EAAE,IAAA;AAC5B,SAAO,OAAO,WAAW,IAAI,IAAI;AACnC;AAMO,SAAS,mBACd,YACA,YAC4C;AAC5C,SAAO,IAAI;AAAA,IACT,WAAW,IAAI,CAAC,UAAU,CAAC,MAAM,MAAM,mBAAmB,OAAO,UAAU,CAAC,CAAC;AAAA,EAAA;AAEjF;"}