@bitflow/core 0.5.0 → 0.5.4

package/dist/index.esm.mjs

@@ -0,0 +1,703 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// ../../scripts/emotion-shim.js
+import { jsx } from "@emotion/react";
+
+// src/bits.ts
+var makeEvaluate = (evaluateMap) => ({ task, answer }) => {
+  const subtype = task.subtype;
+  const evaluate = evaluateMap[subtype];
+  if (!evaluate) {
+    throw new Error("subtype not supported");
+  }
+  return evaluate({ answer, task });
+};
+
+// src/bitsSchema.ts
+import * as z from "zod";
+var FeedbackMessageSchema = z.object({
+  message: z.string(),
+  severity: z.enum(["error", "warning", "info", "success"])
+});
+var TaskSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  subtype: z.string(),
+  view: z.record(z.any()),
+  evaluation: z.object({
+    mode: z.enum(["auto", "skip", "manual"]),
+    enableRetry: z.boolean(),
+    showFeedback: z.boolean()
+  }),
+  feedback: z.record(z.any()).optional()
+});
+var TaskStatisticSchema = z.object({
+  subtype: z.string(),
+  count: z.number()
+});
+var TaskAnswerSchema = z.object({
+  subtype: z.string()
+});
+var TaskResultSchema = z.object({
+  subtype: z.string(),
+  state: z.enum(["unknown", "manual", "correct", "wrong"]),
+  allowRetry: z.boolean().optional(),
+  feedback: z.any()
+});
+var InputSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  subtype: z.string(),
+  view: z.object({})
+});
+var TitleSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  subtype: z.string(),
+  view: z.object({})
+});
+var StartSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  subtype: z.string(),
+  view: z.object({})
+});
+var EndSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  subtype: z.string(),
+  view: z.object({})
+});
+
+// src/do.ts
+var isDoStartedTry = (d) => {
+  return d.status === "started";
+};
+var isDoFinishedTry = (d) => {
+  return d.status === "finished";
+};
+var isDoSkippedTry = (d) => {
+  return d.status === "skipped";
+};
+var skipDoTry = (doResult, evaluation = { mode: "skip" }) => {
+  const { tries } = doResult;
+  let { maxPoints } = doResult;
+  const currentTry = tries[tries.length - 1];
+  const hasTry = tries.find((doTry) => doTry.node.id === currentTry.node.id && doTry.status !== "started");
+  if (!hasTry && (evaluation == null ? void 0 : evaluation.mode) !== "skip") {
+    maxPoints += 1;
+  }
+  tries[tries.length - 1] = __spreadProps(__spreadValues({}, currentTry), {
+    evaluation,
+    status: "skipped",
+    endDate: new Date()
+  });
+  return __spreadProps(__spreadValues({}, doResult), {
+    maxPoints,
+    tries
+  });
+};
+var finishDoTry = (doResult, answer, result) => {
+  var _a, _b;
+  const { tries } = doResult;
+  let { points, maxPoints } = doResult;
+  const currentTry = tries[tries.length - 1];
+  const hasTry = tries.find((doTry) => doTry.node.id === currentTry.node.id && doTry.status !== "started");
+  if (!hasTry && (result == null ? void 0 : result.state) !== "unknown") {
+    maxPoints += 1;
+  }
+  tries[tries.length - 1] = __spreadProps(__spreadValues({}, currentTry), {
+    status: "finished",
+    endDate: new Date(),
+    answer,
+    result
+  });
+  const lastTry = tries.filter(isDoFinishedTry).find((doTry) => doTry.node.id === currentTry.node.id && currentTry.try - 1 === doTry.try);
+  if (!lastTry && (result == null ? void 0 : result.state) === "correct") {
+    points += 1;
+  } else if (((_a = lastTry == null ? void 0 : lastTry.result) == null ? void 0 : _a.state) === "correct" && (result == null ? void 0 : result.state) !== "correct") {
+    points -= 1;
+  } else if (((_b = lastTry == null ? void 0 : lastTry.result) == null ? void 0 : _b.state) !== "correct" && (result == null ? void 0 : result.state) === "correct") {
+    points += 1;
+  }
+  return __spreadProps(__spreadValues({}, doResult), {
+    maxPoints,
+    points,
+    tries
+  });
+};
+var retryDoTry = (doResult) => {
+  const { tries } = doResult;
+  const lastTry = tries[tries.length - 1];
+  tries.push({
+    status: "started",
+    try: lastTry.try + 1,
+    startDate: new Date(),
+    node: __spreadValues({}, lastTry.node)
+  });
+  return __spreadProps(__spreadValues({}, doResult), { tries });
+};
+
+// src/doSchema.ts
+import { z as z3 } from "zod";
+
+// src/flowSchema.ts
+import { z as z2 } from "zod";
+var NodeBaseSchema = z2.object({
+  id: z2.string(),
+  position: z2.object({
+    x: z2.number(),
+    y: z2.number()
+  })
+});
+var FlowCheckpointNodeSchema = NodeBaseSchema.merge(z2.object({
+  type: z2.literal("checkpoint")
+}));
+var FlowSynchronizeNodeSchema = NodeBaseSchema.merge(z2.object({
+  type: z2.literal("synchronize"),
+  data: z2.object({
+    unlocked: z2.boolean()
+  })
+}));
+var makeFlowTaskNodeSchema = (task) => NodeBaseSchema.merge(z2.object({
+  type: z2.literal("task"),
+  data: task
+}));
+var makeFlowStartNodeSchema = (start) => NodeBaseSchema.merge(z2.object({
+  type: z2.literal("start"),
+  data: start
+}));
+var makeFlowEndNodeSchema = (end) => NodeBaseSchema.merge(z2.object({
+  type: z2.literal("end"),
+  data: end
+}));
+var makeFlowInputNodeSchema = (input) => NodeBaseSchema.merge(z2.object({
+  type: z2.literal("input"),
+  data: input
+}));
+var makeFlowTitleNodeSchema = (title) => NodeBaseSchema.merge(z2.object({
+  type: z2.literal("title"),
+  data: title
+}));
+var EqualConditionSchema = z2.object({
+  type: z2.literal("equal"),
+  not: z2.boolean(),
+  nodeId: z2.string(),
+  key: z2.string(),
+  value: z2.union([z2.string(), z2.number()])
+});
+var TrueConditionSchema = z2.object({
+  type: z2.literal("true"),
+  not: z2.boolean(),
+  nodeId: z2.string(),
+  key: z2.string()
+});
+var GreaterConditionSchema = z2.object({
+  type: z2.literal("greater"),
+  include: z2.boolean(),
+  not: z2.boolean(),
+  nodeId: z2.string(),
+  key: z2.string(),
+  value: z2.number()
+});
+var LessConditionSchema = z2.object({
+  type: z2.literal("less"),
+  include: z2.boolean(),
+  not: z2.boolean(),
+  nodeId: z2.string(),
+  key: z2.string(),
+  value: z2.number()
+});
+var InConditionSchema = z2.object({
+  type: z2.literal("in"),
+  not: z2.boolean(),
+  nodeId: z2.string(),
+  key: z2.string(),
+  value: z2.array(z2.union([z2.string(), z2.number()]))
+});
+var PrimitiveConditionSchema = z2.union([
+  EqualConditionSchema,
+  TrueConditionSchema,
+  GreaterConditionSchema,
+  LessConditionSchema,
+  InConditionSchema
+]);
+var AndConditionSchema = z2.object({
+  type: z2.literal("and"),
+  conditions: z2.array(PrimitiveConditionSchema)
+});
+var OrConditionSchema = z2.object({
+  type: z2.literal("or"),
+  conditions: z2.array(PrimitiveConditionSchema)
+});
+var ConditionSchema = z2.union([
+  PrimitiveConditionSchema,
+  AndConditionSchema,
+  OrConditionSchema
+]);
+var SplitAnswerSchema = z2.object({
+  condition: ConditionSchema
+});
+var FlowSplitAnswerNodeSchema = NodeBaseSchema.merge(z2.object({
+  type: z2.literal("split-answer"),
+  data: SplitAnswerSchema
+}));
+var SplitResultSchema = z2.object({
+  condition: ConditionSchema
+});
+var FlowSplitResultNodeSchema = NodeBaseSchema.merge(z2.object({
+  type: z2.literal("split-result"),
+  data: SplitResultSchema
+}));
+var SplitPointsSchema = z2.object({
+  points: z2.number()
+});
+var FlowSplitPointsNodeSchema = NodeBaseSchema.merge(z2.object({
+  type: z2.literal("split-points"),
+  data: SplitPointsSchema
+}));
+var PortalInputSchema = z2.object({
+  portal: z2.string(),
+  description: z2.string()
+});
+var PortalOutputSchema = z2.object({
+  portal: z2.string(),
+  description: z2.string()
+});
+var FlowPortalInputNodeSchema = NodeBaseSchema.merge(z2.object({
+  type: z2.literal("portal-input"),
+  data: PortalInputSchema
+}));
+var FlowPortalOutputNodeSchema = NodeBaseSchema.merge(z2.object({
+  type: z2.literal("portal-output"),
+  data: PortalOutputSchema
+}));
+var FlowSplitRandomNodeSchema = NodeBaseSchema.merge(z2.object({
+  type: z2.literal("split-random")
+}));
+var ControlFlowNodeSchema = z2.union([
+  FlowSplitAnswerNodeSchema,
+  FlowSplitResultNodeSchema,
+  FlowSplitPointsNodeSchema,
+  FlowSplitRandomNodeSchema,
+  FlowPortalInputNodeSchema,
+  FlowPortalOutputNodeSchema
+]);
+var makeInteractiveFlowNodeSchema = ({
+  start,
+  end,
+  input,
+  title,
+  task
+}) => z2.union([
+  makeFlowStartNodeSchema(start),
+  makeFlowEndNodeSchema(end),
+  makeFlowInputNodeSchema(input),
+  makeFlowTaskNodeSchema(task),
+  makeFlowTitleNodeSchema(title),
+  FlowSynchronizeNodeSchema,
+  FlowCheckpointNodeSchema
+]);
+var FlowEdgeSchema = z2.object({
+  id: z2.string(),
+  source: z2.string(),
+  sourceHandle: z2.union([
+    z2.literal("a"),
+    z2.literal("b"),
+    z2.literal("c"),
+    z2.literal("d"),
+    z2.literal("e"),
+    z2.literal("f")
+  ]).optional(),
+  target: z2.string()
+});
+var makeFlowNodeSchema = ({
+  end,
+  input,
+  start,
+  task,
+  title
+}) => z2.union([
+  FlowSplitAnswerNodeSchema,
+  FlowSplitResultNodeSchema,
+  FlowSplitPointsNodeSchema,
+  FlowSplitRandomNodeSchema,
+  FlowPortalInputNodeSchema,
+  FlowPortalOutputNodeSchema,
+  FlowSynchronizeNodeSchema,
+  FlowCheckpointNodeSchema,
+  makeFlowEndNodeSchema(end),
+  makeFlowInputNodeSchema(input),
+  makeFlowStartNodeSchema(start),
+  makeFlowTaskNodeSchema(task),
+  makeFlowTitleNodeSchema(title)
+]);
+var makeFlowSchema = ({
+  end,
+  input,
+  start,
+  task,
+  title
+}) => z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  language: z2.enum(["en", "de", "fr", "es", "nl", "pt", "tr", "it"]),
+  visibility: z2.enum(["public", "private", "unlisted"]),
+  draft: z2.boolean(),
+  nodes: z2.array(makeFlowNodeSchema({ start, end, input, title, task })),
+  edges: z2.array(FlowEdgeSchema),
+  zoom: z2.number().positive().default(1),
+  position: z2.tuple([z2.number(), z2.number()]).default([0, 0])
+}).refine((data) => {
+  const ids = data.nodes.map((n) => n.id);
+  for (let edge of data.edges) {
+    if (!ids.includes(edge.source) || !ids.includes(edge.target)) {
+      return false;
+    }
+  }
+  return true;
+}, { message: "Target and source of an edge need to be valid node ids." });
+
+// src/doSchema.ts
+var makeDoBaseTrySchema = (flowNodeSchemas) => z3.object({
+  node: makeInteractiveFlowNodeSchema(flowNodeSchemas),
+  startDate: z3.date(),
+  try: z3.number(),
+  status: z3.string()
+});
+var makeDoStartedTry = (flowNodeSchemas) => makeDoBaseTrySchema(flowNodeSchemas).merge(z3.object({
+  status: z3.literal("started")
+}));
+var makeDoFinishedTry = (flowNodeSchemas) => makeDoBaseTrySchema(flowNodeSchemas).merge(z3.object({
+  status: z3.literal("finished"),
+  endDate: z3.date(),
+  answer: TaskAnswerSchema.optional(),
+  result: TaskResultSchema.optional()
+}));
+var makeDoSkippedTry = (flowNodeSchemas) => makeDoBaseTrySchema(flowNodeSchemas).merge(z3.object({
+  status: z3.literal("skipped"),
+  endDate: z3.date()
+}));
+
+// src/findLast.ts
+function findLast(array, predicate) {
+  let l = array.length;
+  while (l--) {
+    if (predicate(array[l], l, array))
+      return array[l];
+  }
+  return null;
+}
+
+// src/flow.ts
+var isFlowTaskNode = (n) => {
+  if (n.type === "task") {
+    return true;
+  }
+  return false;
+};
+var isFlowStartNode = (n) => {
+  if (n.type === "start") {
+    return true;
+  }
+  return false;
+};
+var isFlowEndNode = (n) => {
+  if (n.type === "end") {
+    return true;
+  }
+  return false;
+};
+var isFlowInputNode = (n) => {
+  if (n.type === "input") {
+    return true;
+  }
+  return false;
+};
+var isFlowTitleNode = (n) => {
+  if (n.type === "title") {
+    return true;
+  }
+  return false;
+};
+var isFlowSplitAnswerNode = (n) => {
+  return n.type === "split-answer";
+};
+var isFlowSplitResultNode = (n) => {
+  return n.type === "split-result";
+};
+var isFlowSplitPointsNode = (n) => {
+  return n.type === "split-points";
+};
+var isFlowPortalInputNode = (n) => {
+  return n.type === "portal-input";
+};
+var isFlowPortalOutputNode = (n) => {
+  return n.type === "portal-output";
+};
+var isFlowSplitRandomNode = (n) => {
+  return n.type === "split-random";
+};
+var isControlFlowNode = (n) => {
+  return n.type === "portal-input" || n.type === "portal-output" || n.type === "split-answer" || n.type === "split-points" || n.type === "split-random" || n.type === "split-result";
+};
+var isInteractiveFlowNode = (n) => {
+  if (n.type === "checkpoint" || n.type === "end" || n.type === "input" || n.type === "start" || n.type === "synchronize" || n.type === "task" || n.type === "title") {
+    return true;
+  }
+  return false;
+};
+var extractInteractiveFlowPublicNode = (n) => {
+  if (n.type === "task") {
+    return {
+      id: n.id,
+      type: n.type,
+      data: {
+        name: n.data.name,
+        subtype: n.data.subtype,
+        view: n.data.view
+      }
+    };
+  } else if (n.type === "synchronize" || n.type === "checkpoint") {
+    return {
+      id: n.id,
+      type: n.type
+    };
+  } else if (n.type === "input") {
+    return {
+      id: n.id,
+      type: n.type,
+      data: n.data
+    };
+  } else if (n.type === "end") {
+    return {
+      id: n.id,
+      type: n.type,
+      data: n.data
+    };
+  } else if (n.type === "start") {
+    return {
+      id: n.id,
+      type: n.type,
+      data: n.data
+    };
+  }
+  return {
+    id: n.id,
+    type: n.type,
+    data: n.data
+  };
+};
+
+// src/groupBy.ts
+function groupBy(array, by) {
+  const grouped = [];
+  let index = 0;
+  const indexes = {};
+  let l = 0;
+  while (l < array.length) {
+    const value = array[l];
+    const key = by(value);
+    if (indexes[key] === void 0) {
+      indexes[key] = index;
+      index++;
+    }
+    if (!grouped[indexes[key]]) {
+      grouped[indexes[key]] = [value];
+    } else {
+      grouped[indexes[key]].push(value);
+    }
+    l++;
+  }
+  return grouped;
+}
+
+// src/lerpColor.ts
+function lerpColor(a, b, amount) {
+  let ah = +a.replace("#", "0x"), ar = ah >> 16, ag = ah >> 8 & 255, ab = ah & 255, bh = +b.replace("#", "0x"), br = bh >> 16, bg = bh >> 8 & 255, bb = bh & 255, rr = ar + amount * (br - ar), rg = ag + amount * (bg - ag), rb = ab + amount * (bb - ab);
+  return "#" + ((1 << 24) + (rr << 16) + (rg << 8) + rb | 0).toString(16).slice(1);
+}
+
+// src/levenshtein.ts
+function _min(d0, d1, d2, bx, ay) {
+  return d0 < d1 || d2 < d1 ? d0 > d2 ? d2 + 1 : d0 + 1 : bx === ay ? d1 : d1 + 1;
+}
+var levenshtein = (a, b) => {
+  if (a === b) {
+    return 0;
+  }
+  if (a.length > b.length) {
+    var tmp = a;
+    a = b;
+    b = tmp;
+  }
+  var la = a.length;
+  var lb = b.length;
+  while (la > 0 && a.charCodeAt(la - 1) === b.charCodeAt(lb - 1)) {
+    la--;
+    lb--;
+  }
+  var offset = 0;
+  while (offset < la && a.charCodeAt(offset) === b.charCodeAt(offset)) {
+    offset++;
+  }
+  la -= offset;
+  lb -= offset;
+  if (la === 0 || lb < 3) {
+    return lb;
+  }
+  let x = 0;
+  let y;
+  let d0;
+  let d1;
+  let d2;
+  let d3;
+  let dd = 0;
+  let dy;
+  let ay;
+  let bx0;
+  let bx1;
+  let bx2;
+  let bx3;
+  let vector = [];
+  for (y = 0; y < la; y++) {
+    vector.push(y + 1);
+    vector.push(a.charCodeAt(offset + y));
+  }
+  let len = vector.length - 1;
+  for (; x < lb - 3; ) {
+    bx0 = b.charCodeAt(offset + (d0 = x));
+    bx1 = b.charCodeAt(offset + (d1 = x + 1));
+    bx2 = b.charCodeAt(offset + (d2 = x + 2));
+    bx3 = b.charCodeAt(offset + (d3 = x + 3));
+    dd = x += 4;
+    for (y = 0; y < len; y += 2) {
+      dy = vector[y];
+      ay = vector[y + 1];
+      d0 = _min(dy, d0, d1, bx0, ay);
+      d1 = _min(d0, d1, d2, bx1, ay);
+      d2 = _min(d1, d2, d3, bx2, ay);
+      dd = _min(d2, d3, dd, bx3, ay);
+      vector[y] = dd;
+      d3 = d2;
+      d2 = d1;
+      d1 = d0;
+      d0 = dy;
+    }
+  }
+  for (; x < lb; ) {
+    bx0 = b.charCodeAt(offset + (d0 = x));
+    dd = ++x;
+    for (y = 0; y < len; y += 2) {
+      dy = vector[y];
+      vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]);
+      d0 = dy;
+    }
+  }
+  return dd;
+};
+
+// src/uuid.ts
+function uuidv4() {
+  var uuid = "", i, random;
+  for (i = 0; i < 32; i++) {
+    random = Math.random() * 16 | 0;
+    if (i == 8 || i == 12 || i == 16 || i == 20) {
+      uuid += "-";
+    }
+    uuid += (i == 12 ? 4 : i == 16 ? random & 3 | 8 : random).toString(16);
+  }
+  return uuid;
+}
+export {
+  AndConditionSchema,
+  ConditionSchema,
+  ControlFlowNodeSchema,
+  EndSchema,
+  EqualConditionSchema,
+  FeedbackMessageSchema,
+  FlowCheckpointNodeSchema,
+  FlowEdgeSchema,
+  FlowPortalInputNodeSchema,
+  FlowPortalOutputNodeSchema,
+  FlowSplitAnswerNodeSchema,
+  FlowSplitPointsNodeSchema,
+  FlowSplitRandomNodeSchema,
+  FlowSplitResultNodeSchema,
+  FlowSynchronizeNodeSchema,
+  GreaterConditionSchema,
+  InConditionSchema,
+  InputSchema,
+  LessConditionSchema,
+  OrConditionSchema,
+  PortalInputSchema,
+  PortalOutputSchema,
+  PrimitiveConditionSchema,
+  SplitAnswerSchema,
+  SplitPointsSchema,
+  SplitResultSchema,
+  StartSchema,
+  TaskAnswerSchema,
+  TaskResultSchema,
+  TaskSchema,
+  TaskStatisticSchema,
+  TitleSchema,
+  TrueConditionSchema,
+  extractInteractiveFlowPublicNode,
+  findLast,
+  finishDoTry,
+  groupBy,
+  isControlFlowNode,
+  isDoFinishedTry,
+  isDoSkippedTry,
+  isDoStartedTry,
+  isFlowEndNode,
+  isFlowInputNode,
+  isFlowPortalInputNode,
+  isFlowPortalOutputNode,
+  isFlowSplitAnswerNode,
+  isFlowSplitPointsNode,
+  isFlowSplitRandomNode,
+  isFlowSplitResultNode,
+  isFlowStartNode,
+  isFlowTaskNode,
+  isFlowTitleNode,
+  isInteractiveFlowNode,
+  lerpColor,
+  levenshtein,
+  makeDoBaseTrySchema,
+  makeDoFinishedTry,
+  makeDoSkippedTry,
+  makeDoStartedTry,
+  makeEvaluate,
+  makeFlowEndNodeSchema,
+  makeFlowInputNodeSchema,
+  makeFlowNodeSchema,
+  makeFlowSchema,
+  makeFlowStartNodeSchema,
+  makeFlowTaskNodeSchema,
+  makeFlowTitleNodeSchema,
+  makeInteractiveFlowNodeSchema,
+  retryDoTry,
+  skipDoTry,
+  uuidv4
+};
+//# sourceMappingURL=index.esm.mjs.map