@smithers-orchestrator/components 0.16.0

package/src/index.js

@@ -0,0 +1,62 @@
+// @smithers-type-exports-begin
+/**
+ * @template Ctx
+ * @typedef {import("@smithers-orchestrator/scheduler/CachePolicy").CachePolicy<Ctx>} CachePolicy
+ */
+/** @typedef {import("@smithers-orchestrator/scheduler").EngineDecision} EngineDecision */
+/** @typedef {import("@smithers-orchestrator/graph").ExtractOptions} ExtractOptions */
+/** @typedef {import("@smithers-orchestrator/graph").HostElement} HostElement */
+/** @typedef {import("@smithers-orchestrator/graph").HostNode} HostNode */
+/** @typedef {import("@smithers-orchestrator/graph").HostText} HostText */
+/**
+ * @template T
+ * @typedef {import("@smithers-orchestrator/driver/OutputAccessor").InferOutputEntry<T>} InferOutputEntry
+ */
+/**
+ * @template TTable
+ * @typedef {import("@smithers-orchestrator/driver/OutputAccessor").InferRow<TTable>} InferRow
+ */
+/**
+ * @template Schema
+ * @typedef {import("@smithers-orchestrator/driver/OutputAccessor").OutputAccessor<Schema>} OutputAccessor
+ */
+/** @typedef {import("@smithers-orchestrator/driver/OutputKey").OutputKey} OutputKey */
+/** @typedef {import("@smithers-orchestrator/scheduler").RenderContext} RenderContext */
+/** @typedef {import("@smithers-orchestrator/scheduler/RetryPolicy").RetryPolicy} RetryPolicy */
+/** @typedef {import("@smithers-orchestrator/driver/RunAuthContext").RunAuthContext} RunAuthContext */
+/** @typedef {import("@smithers-orchestrator/driver").RunOptions} RunOptions */
+/** @typedef {import("@smithers-orchestrator/driver").RunResult} RunResult */
+/** @typedef {import("@smithers-orchestrator/db/SchemaRegistryEntry").SchemaRegistryEntry} SchemaRegistryEntry */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertLabels} SmithersAlertLabels */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertPolicy} SmithersAlertPolicy */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertPolicyDefaults} SmithersAlertPolicyDefaults */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertPolicyRule} SmithersAlertPolicyRule */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertReaction} SmithersAlertReaction */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertReactionKind} SmithersAlertReactionKind */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertReactionRef} SmithersAlertReactionRef */
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertSeverity} SmithersAlertSeverity */
+/** @typedef {import("@smithers-orchestrator/driver").SmithersCtx} SmithersCtx */
+/** @typedef {import("@smithers-orchestrator/errors/SmithersErrorCode").SmithersErrorCode} SmithersErrorCode */
+/**
+ * @template Schema
+ * @typedef {import("@smithers-orchestrator/driver/WorkflowDefinition").WorkflowDefinition<Schema>} SmithersWorkflow
+ */
+/**
+ * @template Schema
+ * @typedef {import("@smithers-orchestrator/driver/WorkflowDriverOptions").WorkflowDriverOptions<Schema>} SmithersWorkflowDriverOptions
+ */
+/** @typedef {import("@smithers-orchestrator/scheduler").SmithersWorkflowOptions} SmithersWorkflowOptions */
+/** @typedef {import("@smithers-orchestrator/graph").TaskDescriptor} TaskDescriptor */
+/** @typedef {import("@smithers-orchestrator/scheduler").WaitReason} WaitReason */
+/** @typedef {import("@smithers-orchestrator/graph").WorkflowGraph} WorkflowGraph */
+/** @typedef {import("@smithers-orchestrator/driver/workflow-types").WorkflowRuntime} WorkflowRuntime */
+/** @typedef {import("@smithers-orchestrator/driver/workflow-types").WorkflowSession} WorkflowSession */
+/** @typedef {import("@smithers-orchestrator/graph").XmlElement} XmlElement */
+/** @typedef {import("@smithers-orchestrator/graph").XmlNode} XmlNode */
+/** @typedef {import("@smithers-orchestrator/graph").XmlText} XmlText */
+// @smithers-type-exports-end
+
+export * from "./components/index.js";
+export { markdownComponents } from "./markdownComponents.js";
+export { renderMdx } from "./renderMdx.js";
+export { zodSchemaToJsonExample } from "./zod-to-example.js";

package/src/markdownComponents.js

@@ -0,0 +1,44 @@
+import React from "react";
+/**
+ * @param {any[]} ...parts
+ */
+function fragment(...parts) {
+    return React.createElement(React.Fragment, null, ...parts);
+}
+/** @type {Record<string, React.FC<any>>} */
+export const markdownComponents = {
+    h1: ({ children }) => fragment("# ", children, "\n\n"),
+    h2: ({ children }) => fragment("## ", children, "\n\n"),
+    h3: ({ children }) => fragment("### ", children, "\n\n"),
+    h4: ({ children }) => fragment("#### ", children, "\n\n"),
+    h5: ({ children }) => fragment("##### ", children, "\n\n"),
+    h6: ({ children }) => fragment("###### ", children, "\n\n"),
+    p: ({ children }) => fragment(children, "\n\n"),
+    blockquote: ({ children }) => fragment("> ", children, "\n"),
+    hr: () => fragment("---\n\n"),
+    ul: ({ children }) => fragment(children, "\n"),
+    ol: ({ children }) => fragment(children, "\n"),
+    li: ({ children }) => fragment("- ", children, "\n"),
+    code: ({ children, className }) => {
+        if (className) {
+            const lang = className.replace("language-", "");
+            return fragment("```", lang, "\n", children, "\n```\n\n");
+        }
+        return fragment("`", children, "`");
+    },
+    pre: ({ children }) => fragment(children),
+    strong: ({ children }) => fragment("**", children, "**"),
+    em: ({ children }) => fragment("*", children, "*"),
+    a: ({ href, children }) => fragment("[", children, "](", href, ")"),
+    br: () => fragment("\n"),
+    img: ({ alt, src }) => fragment("![", alt ?? "", "](", src, ")"),
+    table: ({ children }) => fragment(children, "\n"),
+    thead: ({ children }) => fragment(children),
+    tbody: ({ children }) => fragment(children),
+    tr: ({ children }) => fragment("| ", children, "\n"),
+    th: ({ children }) => fragment(children, " | "),
+    td: ({ children }) => fragment(children, " | "),
+    div: ({ children }) => fragment(children, "\n"),
+    section: ({ children }) => fragment(children, "\n"),
+    span: ({ children }) => fragment(children),
+};

package/src/renderMdx.js

@@ -0,0 +1,26 @@
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { markdownComponents } from "./markdownComponents.js";
+/** @typedef {import("mdx/types").MDXContent} MDXContent */
+/**
+ * Render an MDX component to plain markdown text.
+ *
+ * Injects `markdownComponents` so headings, paragraphs, code blocks, etc.
+ * render as markdown-formatted text instead of HTML tags.
+ *
+ * @param {MDXContent} Component
+ * @param {Record<string, any>} [props]
+ * @returns {string}
+ */
+export function renderMdx(Component, props = {}) {
+    const element = React.createElement(Component, {
+        ...props,
+        components: {
+            ...markdownComponents,
+            ...props.components,
+        },
+    });
+    return renderToStaticMarkup(element)
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}

package/src/types/react-dom-server.d.ts

@@ -0,0 +1 @@
+declare module "react-dom/server";

package/src/types.ts

@@ -0,0 +1,22 @@
+export type { WorkflowDefinition as SmithersWorkflow } from "@smithers-orchestrator/driver/WorkflowDefinition";
+export type { WorkflowDriverOptions as SmithersWorkflowDriverOptions } from "@smithers-orchestrator/driver/WorkflowDriverOptions";
+
+export type {
+  EngineDecision,
+  RenderContext,
+  WaitReason,
+  SmithersWorkflowOptions,
+} from "@smithers-orchestrator/scheduler";
+export type { RunOptions, RunResult, SmithersCtx } from "@smithers-orchestrator/driver";
+export type { WorkflowRuntime, WorkflowSession } from "@smithers-orchestrator/driver/workflow-types";
+export type {
+  ExtractOptions,
+  HostElement,
+  HostNode,
+  HostText,
+  TaskDescriptor,
+  WorkflowGraph,
+  XmlElement,
+  XmlNode,
+  XmlText,
+} from "@smithers-orchestrator/graph";

package/src/zod-to-example.js

@@ -0,0 +1,87 @@
+
+/** @typedef {import("zod").ZodObject<import("zod").ZodRawShape>} ZodObject */
+/** @typedef {import("zod").ZodTypeAny} ZodTypeAny */
+/**
+ * @param {ZodObject} schema
+ * @returns {string}
+ */
+export function zodSchemaToJsonExample(schema) {
+    /** @type {Record<string, unknown>} */
+    const example = {};
+    for (const [key, field] of Object.entries(schema.shape)) {
+        example[key] = zodFieldToExample(/** @type {ZodTypeAny} */ (field));
+    }
+    return JSON.stringify(example, null, 2);
+}
+/**
+ * @param {ZodTypeAny} field
+ * @returns {unknown}
+ */
+function zodFieldToExample(field) {
+    const anyField = /** @type {{
+        description?: string;
+        _def?: { description?: string };
+        _zod?: {
+            bag?: { description?: string };
+            def?: {
+                type?: string;
+                description?: string;
+                element?: ZodTypeAny;
+                values?: unknown[];
+                entries?: Record<string, unknown>;
+                innerType?: ZodTypeAny;
+            };
+        };
+        shape?: Record<string, ZodTypeAny>;
+    }} */ (/** @type {unknown} */ (field));
+    const zod = anyField._zod;
+    const def = zod?.def;
+    if (!def)
+        return "value";
+    const description = anyField.description ??
+        anyField._def?.description ??
+        zod?.bag?.description ??
+        def.description ??
+        "";
+    const typeName = def.type;
+    switch (typeName) {
+        case "string":
+            return description || "string";
+        case "number":
+            return 0;
+        case "boolean":
+            return false;
+        case "array": {
+            const inner = def.element;
+            if (inner && typeof inner === "object")
+                return [zodFieldToExample(inner)];
+            return ["value"];
+        }
+        case "enum": {
+            if (Array.isArray(def.values))
+                return def.values[0] ?? "enum";
+            if (def.entries && typeof def.entries === "object") {
+                const keys = Object.keys(def.entries);
+                return keys[0] ?? "enum";
+            }
+            return "enum";
+        }
+        case "object": {
+            const shape = anyField.shape;
+            if (!shape)
+                return {};
+            /** @type {Record<string, unknown>} */
+            const obj = {};
+            for (const [key, value] of Object.entries(shape)) {
+                obj[key] = zodFieldToExample(value);
+            }
+            return obj;
+        }
+        case "nullable":
+            return def.innerType ? zodFieldToExample(def.innerType) : null;
+        case "optional":
+            return def.innerType ? zodFieldToExample(def.innerType) : undefined;
+        default:
+            return description || "value";
+    }
+}