@scarn/sdk 0.0.0-stage → 0.8.0

package/dist/chunk-y2pv8d6a.js

@@ -0,0 +1,162 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/contracts/artifacts.ts
+var artifactKindSchema = exports_external.enum([
+  "generic",
+  "playwright-trace",
+  "video",
+  "image"
+]);
+var ARTIFACT_SCHEMA_KEYWORD = "x-scarn-artifact";
+var artifactPlatforms = ["github", "jira", "bitbucket"];
+var EMBEDDABLE_ARTIFACT_EXTENSIONS = {
+  jira: [".png", ".gif", ".mp4", ".webm"],
+  github: [],
+  bitbucket: []
+};
+function isEmbeddableArtifactExtension(platform, extension) {
+  return EMBEDDABLE_ARTIFACT_EXTENSIONS[platform].includes(extension.toLowerCase());
+}
+function artifactFileExtension(fileName) {
+  const base = fileName.slice(fileName.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0)
+    return "";
+  return base.slice(dot).toLowerCase();
+}
+function artifactAcceptsFile(accept, fileName) {
+  if (accept.length === 0)
+    return true;
+  return accept.includes(artifactFileExtension(fileName));
+}
+function asRecord(node) {
+  return typeof node === "object" ? node : null;
+}
+function isNullSchema(node) {
+  return asRecord(node)?.["type"] === "null";
+}
+function schemaBranches(record, keyword) {
+  const value = record[keyword];
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "boolean" || typeof entry === "object" && entry !== null && !Array.isArray(entry));
+}
+function readArtifactKeyword(node) {
+  const record = asRecord(node);
+  const keyword = asRecord(record?.[ARTIFACT_SCHEMA_KEYWORD]);
+  if (!keyword)
+    return null;
+  const accept = keyword["accept"];
+  return {
+    accept: Array.isArray(accept) ? accept.filter((entry) => typeof entry === "string") : []
+  };
+}
+function readDescription(node) {
+  const description = asRecord(node)?.["description"];
+  return typeof description === "string" ? description : null;
+}
+function matchArtifactNode(node) {
+  const direct = readArtifactKeyword(node);
+  if (direct) {
+    const types = asRecord(node)?.["type"];
+    return {
+      ...direct,
+      nullable: Array.isArray(types) && types.includes("null"),
+      description: readDescription(node)
+    };
+  }
+  const record = asRecord(node);
+  if (!record)
+    return null;
+  for (const keyword of ["anyOf", "oneOf"]) {
+    const branches = schemaBranches(record, keyword);
+    const nonNull = branches.filter((branch) => !isNullSchema(branch));
+    const [only] = nonNull;
+    if (!only || nonNull.length !== 1 || branches.length !== 2)
+      continue;
+    const inner = readArtifactKeyword(only);
+    if (!inner)
+      continue;
+    return {
+      ...inner,
+      nullable: true,
+      description: readDescription(node) ?? readDescription(only)
+    };
+  }
+  return null;
+}
+var MAX_REF_HOPS = 16;
+function resolveLocalRef(root, ref) {
+  if (!ref.startsWith("#"))
+    return null;
+  const pointer = ref.slice(1);
+  if (pointer === "" || pointer === "/")
+    return root;
+  let current = root;
+  for (const rawToken of pointer.slice(1).split("/")) {
+    const token = rawToken.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (typeof current !== "object" || current === null)
+      return null;
+    current = current[token];
+  }
+  return typeof current === "object" && current !== null ? current : null;
+}
+function findArtifactFields(schema) {
+  if (schema === null || schema === undefined)
+    return [];
+  const root = schema;
+  const fields = new Map;
+  const visit = (node, path, inArray, hops) => {
+    if (hops > MAX_REF_HOPS)
+      return;
+    const record = asRecord(node);
+    if (!record)
+      return;
+    const ref = record["$ref"];
+    if (typeof ref === "string") {
+      const target = resolveLocalRef(root, ref);
+      if (target)
+        visit(target, path, inArray, hops + 1);
+      return;
+    }
+    const match = path ? matchArtifactNode(node) : null;
+    if (match) {
+      if (!fields.has(path)) {
+        fields.set(path, {
+          path,
+          accept: match.accept,
+          nullable: match.nullable,
+          description: match.description,
+          inArray
+        });
+      }
+      return;
+    }
+    for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+      for (const branch of schemaBranches(record, keyword)) {
+        visit(branch, path, inArray, hops + 1);
+      }
+    }
+    const properties = asRecord(record["properties"]);
+    for (const [key, child] of Object.entries(properties ?? {})) {
+      const childNode = child;
+      visit(childNode, path ? `${path}.${key}` : key, inArray, hops);
+    }
+    const items = record["items"];
+    if (items !== undefined)
+      visit(items, `${path}[]`, true, hops);
+    const prefixItems = record["prefixItems"];
+    if (Array.isArray(prefixItems)) {
+      for (const item of prefixItems) {
+        visit(item, `${path}[]`, true, hops);
+      }
+    }
+  };
+  visit(schema, "", false, 0);
+  return [...fields.values()];
+}
+
+export { artifactKindSchema, ARTIFACT_SCHEMA_KEYWORD, artifactPlatforms, EMBEDDABLE_ARTIFACT_EXTENSIONS, isEmbeddableArtifactExtension, artifactFileExtension, artifactAcceptsFile, readArtifactKeyword, matchArtifactNode, findArtifactFields };

package/dist/chunk-y64skrwp.js

@@ -0,0 +1,17 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+export { __export };