@scarn/sdk 0.0.0-stage → 0.8.0

package/dist/chunk-p7yrcmqm.js

@@ -0,0 +1,322 @@
+// @bun
+import {
+  exports_external
+} from "./chunk-skzxcba3.js";
+
+// src/contracts/pipeline-document/json.ts
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapePointerSegment(segment) {
+  return String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function jsonPointer(segments) {
+  return segments.map((segment) => `/${escapePointerSegment(segment)}`).join("");
+}
+function deepEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (Array.isArray(left)) {
+    return Array.isArray(right) && left.length === right.length && left.every((item, index) => deepEqual(item, right[index]));
+  }
+  if (isJsonObject(left) && isJsonObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(right, key) && deepEqual(left[key], right[key]));
+  }
+  return false;
+}
+// src/contracts/pipeline-document/conditions/operators.ts
+var COMPARISON_OPERATORS = [
+  "equal",
+  "notEqual",
+  "lessThan",
+  "lessThanInclusive",
+  "greaterThan",
+  "greaterThanInclusive"
+];
+var CONDITION_OPERATORS = [
+  ...COMPARISON_OPERATORS,
+  "exists",
+  "isEmpty",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "matches",
+  "before",
+  "after",
+  "some",
+  "every",
+  "none"
+];
+var COMPUTED_FUNCTIONS = [
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "count"
+];
+var ORDERING_OPERATORS = new Set([
+  "lessThan",
+  "lessThanInclusive",
+  "greaterThan",
+  "greaterThanInclusive"
+]);
+var STRING_OPERATORS = new Set([
+  "startsWith",
+  "endsWith",
+  "matches"
+]);
+var DATE_OPERATORS = new Set(["before", "after"]);
+var LIST_OPERATORS = new Set(["some", "every", "none"]);
+
+// src/contracts/pipeline-document/schema.ts
+var NODE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var ALIAS_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var nodeIdSchema = exports_external.string().regex(NODE_ID_PATTERN, "Node ids may only contain letters, digits, '_' and '-'");
+var jsonValueSchema = exports_external.json();
+var literalSchema = exports_external.strictObject({ value: jsonValueSchema });
+var scalarArgSchema = exports_external.union([exports_external.string().min(1), literalSchema]);
+var listSchema = exports_external.strictObject({ list: exports_external.array(scalarArgSchema) });
+var argValueSchema = exports_external.union([
+  exports_external.string().min(1),
+  literalSchema,
+  listSchema
+]);
+var computedSourceSchema = exports_external.union([
+  exports_external.array(exports_external.string().min(1)).min(1),
+  exports_external.strictObject({
+    path: exports_external.string().min(1),
+    field: exports_external.string().min(1).optional(),
+    get where() {
+      return conditionSchema.optional();
+    }
+  })
+]);
+var LIST_OPS = new Set(["some", "every", "none"]);
+var UNARY_OPS = new Set(["exists", "isEmpty"]);
+var conditionSchema = exports_external.strictObject({
+  get all() {
+    return exports_external.array(conditionSchema).min(1).optional();
+  },
+  get any() {
+    return exports_external.array(conditionSchema).min(1).optional();
+  },
+  get not() {
+    return conditionSchema.optional();
+  },
+  path: exports_external.string().min(1).optional(),
+  sum: computedSourceSchema.optional(),
+  avg: computedSourceSchema.optional(),
+  min: computedSourceSchema.optional(),
+  max: computedSourceSchema.optional(),
+  count: computedSourceSchema.optional(),
+  weights: exports_external.array(exports_external.number()).min(1).optional(),
+  op: exports_external.enum(CONDITION_OPERATORS).optional(),
+  value: jsonValueSchema.optional(),
+  ref: exports_external.string().min(1).optional(),
+  get where() {
+    return conditionSchema.optional();
+  }
+}).superRefine((condition, ctx) => {
+  const combinators = ["all", "any", "not"].filter((key) => condition[key] !== undefined);
+  const lefts = ["path", ...COMPUTED_FUNCTIONS].filter((key) => condition[key] !== undefined);
+  if (combinators.length > 0) {
+    const extras = Object.keys(condition).filter((key) => key !== combinators[0]);
+    if (combinators.length > 1 || extras.length > 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: `A condition with "${String(combinators[0])}" can't have other keys (found ${[...combinators.slice(1), ...extras].map((key) => `"${key}"`).join(", ")})`
+      });
+    }
+    return;
+  }
+  if (lefts.length !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: lefts.length === 0 ? 'A condition needs exactly one of "path", "sum", "avg", "min", "max", "count", or a combinator "all", "any", "not"' : `A condition can have only one of ${lefts.map((key) => `"${key}"`).join(", ")}`
+    });
+    return;
+  }
+  if (condition.op === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'A condition needs "op"',
+      path: ["op"]
+    });
+    return;
+  }
+  const isList = LIST_OPS.has(condition.op);
+  const isUnary = UNARY_OPS.has(condition.op);
+  if (isList && condition.where === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" needs a "where" condition`,
+      path: ["where"]
+    });
+  }
+  if (!isList && condition.where !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"where" is only allowed with "some", "every" or "none", not "${condition.op}"`,
+      path: ["where"]
+    });
+  }
+  const hasValue = condition.value !== undefined;
+  const hasRef = condition.ref !== undefined;
+  if ((isList || isUnary) && (hasValue || hasRef)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" takes no "value" or "ref"`,
+      path: [hasValue ? "value" : "ref"]
+    });
+  }
+  if (!isList && !isUnary && hasValue === hasRef) {
+    ctx.addIssue({
+      code: "custom",
+      message: `"${condition.op}" needs exactly one of "value" or "ref"`
+    });
+  }
+  if (condition.weights !== undefined && condition.avg === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: '"weights" is only allowed with "avg"',
+      path: ["weights"]
+    });
+  }
+});
+var toleratedFailuresSchema = exports_external.union([
+  exports_external.strictObject({ count: exports_external.int().nonnegative() }),
+  exports_external.strictObject({ percent: exports_external.number().min(0).max(100) })
+]);
+var eachSchema = exports_external.strictObject({
+  over: exports_external.string().min(1),
+  maxConcurrency: exports_external.int().positive().optional(),
+  toleratedFailures: toleratedFailuresSchema.optional()
+});
+var routeShape = {
+  when: conditionSchema.optional(),
+  to: nodeIdSchema,
+  pipeline: exports_external.string().min(1).optional(),
+  args: exports_external.record(exports_external.string().min(1), argValueSchema).optional(),
+  each: eachSchema.optional(),
+  partial: exports_external.literal(true).optional()
+};
+function noPartialWithEach(route, ctx) {
+  if (route.each !== undefined && route.partial !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `A route can't have both "each" and "partial"`,
+      path: ["partial"]
+    });
+  }
+}
+var routeSchema = exports_external.strictObject(routeShape).superRefine(noPartialWithEach);
+var otherwiseSchema = exports_external.strictObject(routeShape).omit({ when: true }).superRefine(noPartialWithEach);
+var startSchema = exports_external.strictObject(routeShape).omit({ partial: true });
+var MATCH_MODES = ["first", "all"];
+var nextSchema = exports_external.strictObject({
+  match: exports_external.enum(MATCH_MODES).optional(),
+  routes: exports_external.array(routeSchema).min(1),
+  otherwise: otherwiseSchema.optional()
+});
+var retrySchema = exports_external.strictObject({
+  on: exports_external.array(exports_external.string().min(1)).min(1),
+  maxAttempts: exports_external.int().positive(),
+  intervalSeconds: exports_external.number().nonnegative().optional(),
+  backoffRate: exports_external.number().positive().optional(),
+  maxDelaySeconds: exports_external.number().nonnegative().optional()
+});
+var catchSchema = exports_external.strictObject({
+  on: exports_external.array(exports_external.string().min(1)).min(1),
+  to: nodeIdSchema,
+  pipeline: exports_external.string().min(1).optional(),
+  args: exports_external.record(exports_external.string().min(1), argValueSchema).optional()
+});
+var stepNodeSchema = exports_external.strictObject({
+  kind: exports_external.literal("step"),
+  title: exports_external.string().optional(),
+  step: exports_external.string().min(1),
+  next: nextSchema.optional(),
+  retry: exports_external.array(retrySchema).optional(),
+  catch: exports_external.array(catchSchema).optional(),
+  timeoutSeconds: exports_external.int().positive().optional(),
+  heartbeatSeconds: exports_external.int().positive().optional(),
+  maxRuns: exports_external.int().positive().optional(),
+  maxTurns: exports_external.int().nonnegative().optional()
+});
+var DEFAULT_MAX_TURNS = 2;
+var DECISION_BODY_MODES = ["optional", "required"];
+var decisionActionSchema = exports_external.strictObject({
+  key: exports_external.string().min(1),
+  label: exports_external.string().min(1),
+  body: exports_external.enum(DECISION_BODY_MODES).optional()
+});
+var waitNodeSchema = exports_external.strictObject({
+  kind: exports_external.literal("wait"),
+  title: exports_external.string().optional(),
+  for: exports_external.enum(["decision", "reply", "event", "timer"]),
+  actions: exports_external.array(decisionActionSchema).optional(),
+  next: nextSchema.optional(),
+  catch: exports_external.array(catchSchema).optional(),
+  timeoutSeconds: exports_external.int().positive().optional(),
+  maxRuns: exports_external.int().positive().optional()
+});
+var succeedNodeSchema = exports_external.strictObject({
+  kind: exports_external.literal("succeed"),
+  title: exports_external.string().optional()
+});
+var failNodeSchema = exports_external.strictObject({
+  kind: exports_external.literal("fail"),
+  title: exports_external.string().optional(),
+  error: exports_external.string().min(1).optional(),
+  cause: exports_external.string().optional()
+});
+var nodeSchema = exports_external.discriminatedUnion("kind", [
+  stepNodeSchema,
+  waitNodeSchema,
+  succeedNodeSchema,
+  failNodeSchema
+]);
+var pipelineDocumentSchema = exports_external.strictObject({
+  $schema: exports_external.string().optional(),
+  schemaVersion: exports_external.literal(1),
+  key: exports_external.string().min(1),
+  title: exports_external.string().optional(),
+  timeoutSeconds: exports_external.int().positive().optional(),
+  workItemFields: exports_external.record(exports_external.string().regex(ALIAS_PATTERN, "Aliases must be identifiers (letters, digits, '_')"), exports_external.string().min(1)).optional(),
+  start: startSchema,
+  nodes: exports_external.record(nodeIdSchema, nodeSchema)
+});
+function pipelineDocumentJsonSchema() {
+  return exports_external.toJSONSchema(pipelineDocumentSchema, { io: "input" });
+}
+// src/contracts/pipeline-document/routes.ts
+function routeEntries(next) {
+  if (next === undefined) {
+    return [];
+  }
+  const entries = next.routes.map((route, index) => ({
+    kind: "route",
+    index,
+    route,
+    pointer: ["routes", index]
+  }));
+  if (next.otherwise !== undefined) {
+    entries.push({
+      kind: "otherwise",
+      index: 0,
+      route: next.otherwise,
+      pointer: ["otherwise"]
+    });
+  }
+  return entries;
+}
+function routeAt(next, kind, index) {
+  if (next === undefined) {
+    return;
+  }
+  return kind === "otherwise" ? next.otherwise : next.routes[index];
+}
+export { isJsonObject, jsonPointer, deepEqual, COMPARISON_OPERATORS, CONDITION_OPERATORS, COMPUTED_FUNCTIONS, ORDERING_OPERATORS, STRING_OPERATORS, DATE_OPERATORS, LIST_OPERATORS, NODE_ID_PATTERN, ALIAS_PATTERN, literalSchema, listSchema, argValueSchema, computedSourceSchema, conditionSchema, toleratedFailuresSchema, eachSchema, routeSchema, otherwiseSchema, startSchema, MATCH_MODES, nextSchema, retrySchema, catchSchema, stepNodeSchema, DEFAULT_MAX_TURNS, DECISION_BODY_MODES, decisionActionSchema, waitNodeSchema, succeedNodeSchema, failNodeSchema, nodeSchema, pipelineDocumentSchema, pipelineDocumentJsonSchema, routeEntries, routeAt };

package/dist/chunk-rt9tq4j6.js

@@ -0,0 +1,116 @@
+// @bun
+// src/jsonc.ts
+var stripJsoncComments = (content) => {
+  let result = "";
+  let inString = false;
+  let escapeNextCharacter = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const character = content.charAt(index);
+    const nextCharacter = content.charAt(index + 1);
+    if (lineComment) {
+      if (character === `
+`) {
+        lineComment = false;
+        result += character;
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (character === "*" && nextCharacter === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      result += character;
+      if (escapeNextCharacter) {
+        escapeNextCharacter = false;
+        continue;
+      }
+      if (character === "\\") {
+        escapeNextCharacter = true;
+        continue;
+      }
+      if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (character === "/" && nextCharacter === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    result += character;
+  }
+  return result;
+};
+var stripTrailingCommas = (content) => {
+  let result = "";
+  let inString = false;
+  let escapeNextCharacter = false;
+  for (let index = 0;index < content.length; index += 1) {
+    const character = content.charAt(index);
+    if (inString) {
+      result += character;
+      if (escapeNextCharacter) {
+        escapeNextCharacter = false;
+        continue;
+      }
+      if (character === "\\") {
+        escapeNextCharacter = true;
+        continue;
+      }
+      if (character === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      result += character;
+      continue;
+    }
+    if (character === ",") {
+      let lookaheadIndex = index + 1;
+      while (lookaheadIndex < content.length) {
+        const lookaheadCharacter2 = content.charAt(lookaheadIndex);
+        if (/\s/u.test(lookaheadCharacter2)) {
+          lookaheadIndex += 1;
+          continue;
+        }
+        if (lookaheadCharacter2 === "}" || lookaheadCharacter2 === "]") {
+          break;
+        }
+        result += character;
+        break;
+      }
+      if (lookaheadIndex >= content.length) {
+        continue;
+      }
+      const lookaheadCharacter = content.charAt(lookaheadIndex);
+      if (lookaheadCharacter === "}" || lookaheadCharacter === "]") {
+        continue;
+      }
+      continue;
+    }
+    result += character;
+  }
+  return result;
+};
+var parseJsonc = (content) => JSON.parse(stripTrailingCommas(stripJsoncComments(content)));
+
+export { stripJsoncComments, stripTrailingCommas, parseJsonc };