@media-quest/engine 0.0.26 → 0.0.27

package/dist/public-api.js

@@ -0,0 +1,1533 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/public-api.ts
+var public_api_exports = {};
+__export(public_api_exports, {
+  ButtonClickAction: () => ButtonClickAction,
+  Condition: () => Condition,
+  DCss: () => DCss,
+  DDiv: () => DDiv,
+  DElement: () => DElement,
+  DImg: () => DImg,
+  DStyle: () => DStyle,
+  DText: () => DText,
+  DUtil: () => DUtil,
+  MqEvent: () => MqEvent,
+  PageComponent: () => PageComponent,
+  PageDto: () => PageDto,
+  Rule: () => Rule,
+  RuleEngine: () => RuleEngine,
+  SchemaEngine: () => SchemaEngine,
+  Task: () => Task
+});
+module.exports = __toCommonJS(public_api_exports);
+
+// src/engine/history-que.ts
+var HistoryQue = class {
+  history = [];
+  getFacts() {
+    const answers = this.history.map((h) => h.collectedFacts).flat(1);
+    return answers;
+  }
+  addToHistory(result) {
+    this.history.push(result);
+  }
+};
+
+// src/utils/DUtil.ts
+var DUtil;
+((DUtil2) => {
+  DUtil2.randomString = (length) => {
+    const letters = "abcdefghijklmnopqrstuvxyz";
+    const uppercase = letters.toUpperCase();
+    const all = letters + uppercase;
+    const abs = Math.abs(length);
+    let result = "";
+    for (let i = 0; i < abs; i++) {
+      const char = all.charAt(Math.floor(Math.random() * all.length));
+      result += char;
+    }
+    return result;
+  };
+  DUtil2.randomObjectId = () => (0, DUtil2.randomString)(32);
+  DUtil2.deleteProp = (obj, key) => {
+    delete obj[key];
+    return obj;
+  };
+  DUtil2.isInRange = (min, max) => {
+    return (value) => value >= min && value <= max;
+  };
+  DUtil2.isInfinity = (number) => {
+    return number === Number.POSITIVE_INFINITY || number === Number.NEGATIVE_INFINITY || number === Infinity;
+  };
+  DUtil2.isNonEmptyArray = (array) => {
+    return array.length > 0;
+  };
+  DUtil2.neverCheck = (args) => {
+    console.log("OOPS: This value slipped through the never-check", args);
+  };
+  DUtil2.isString = (str) => typeof str === "string";
+  DUtil2.hasKey = (obj, key) => {
+    if (!(0, DUtil2.isRecord)(obj)) {
+      return false;
+    }
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  };
+  DUtil2.isRecord = (obj) => {
+    if (!obj) {
+      return false;
+    }
+    if (Array.isArray(obj)) {
+      return false;
+    }
+    if (typeof obj !== "object") {
+      return false;
+    }
+    if (obj === null) {
+      return false;
+    }
+    return true;
+  };
+  DUtil2.isBool = (obj) => typeof obj === "boolean";
+  DUtil2.isTrue = (bool) => bool === true;
+  DUtil2.isFalse = (bool) => bool === false;
+  DUtil2.isDefined = (obj) => {
+    const notNull = obj !== null;
+    const notUndefined = obj !== void 0;
+    return notNull && notUndefined;
+  };
+  DUtil2.hasKind = (obj) => {
+    if (!(0, DUtil2.hasKey)(obj, "kind")) {
+      return false;
+    }
+    if (typeof obj.kind !== "string") {
+      return false;
+    }
+    return obj.kind.length > 0;
+  };
+  DUtil2.hasValue = (obj) => {
+    return (0, DUtil2.hasKey)(obj, "value");
+  };
+  DUtil2.isNumber = (value) => {
+    const isNumber2 = typeof value === "number";
+    const notNaN = !Number.isNaN(value);
+    return isNumber2 && notNaN;
+  };
+  DUtil2.maxFn = (upperLimit) => {
+    return (value) => {
+      return Math.min(value, upperLimit);
+    };
+  };
+  DUtil2.minFn = (lowerLimit) => {
+    return (value) => {
+      return Math.min(value, lowerLimit);
+    };
+  };
+})(DUtil || (DUtil = {}));
+
+// src/rules/condition.ts
+var Condition;
+((Condition2) => {
+  Condition2.evaluate = (condition, facts) => {
+    let result = false;
+    switch (condition.kind) {
+      case "string-condition":
+        result = evaluateSimple(condition, facts);
+        break;
+      case "numeric-condition":
+        result = evaluateSimple(condition, facts);
+        break;
+      case "complex-condition":
+        result = evaluateComplex(condition, facts);
+        break;
+      default:
+        const check = condition;
+    }
+    return result;
+  };
+  const evaluateComplex = (condition, facts) => {
+    if (condition.some.length === 0 && condition.all.length === 0) {
+      return false;
+    }
+    const allSolved = condition.all.map((condition2) => {
+      return evaluateSimple(condition2, facts);
+    });
+    const someEvaluated = condition.some.map((condition2) => {
+      return evaluateSimple(condition2, facts);
+    });
+    const allResult = allSolved.every(DUtil.isTrue);
+    const someResult = someEvaluated.length === 0 || someEvaluated.some(DUtil.isTrue);
+    return someResult && allResult;
+  };
+  const evaluateSimple = (condition, facts) => {
+    const fact = facts.find((f) => f.referenceId === condition.referenceId);
+    if (!fact) {
+      return false;
+    }
+    let res = false;
+    switch (condition.kind) {
+      case "numeric-condition":
+        if (fact.kind === "numeric-fact") {
+          res = evaluateNumeric(condition, fact.value);
+        }
+        break;
+      case "string-condition":
+        if (fact.kind === "string-fact") {
+          res = evaluateString(condition, fact.value);
+        }
+        break;
+      default:
+        const check = condition;
+    }
+    return res;
+  };
+  Condition2.isEmpty = (complex) => {
+    return complex.all.length === 0 && complex.some.length === 0;
+  };
+  const evaluateString = (condition, value) => {
+    const operator = condition.operator;
+    let result = false;
+    switch (operator) {
+      case "eq":
+        result = condition.value === value;
+        break;
+      case "not-eq":
+        result = condition.value !== value;
+        break;
+      case "shorter-then":
+        result = condition.value !== value;
+        break;
+      case "longer-then":
+        result = condition.value !== value;
+        break;
+      default:
+        const check = operator;
+    }
+    return result;
+  };
+  const evaluateNumeric = (condition, value) => {
+    const op = condition.operator;
+    const conditionValue = condition.value;
+    let result = false;
+    switch (op) {
+      case "eq":
+        result = value === conditionValue;
+        break;
+      case "not-eq":
+        result = value !== conditionValue;
+        break;
+      case "greater-then":
+        result = value > conditionValue;
+        break;
+      case "greater-then-inclusive":
+        result = value >= conditionValue;
+        break;
+      case "less-then":
+        result = value < conditionValue;
+        break;
+      case "less-then-inclusive":
+        result = value <= conditionValue;
+        break;
+      default:
+        const check = op;
+    }
+    return result;
+  };
+  const _getAllSimple = (condition) => {
+    const simple = [];
+    switch (condition.kind) {
+      case "complex-condition":
+        simple.push(...condition.all);
+        simple.push(...condition.some);
+        break;
+      case "numeric-condition":
+        simple.push(condition);
+        break;
+      case "string-condition":
+        simple.push(condition);
+        break;
+      default:
+        DUtil.neverCheck(condition);
+    }
+    return simple;
+  };
+  Condition2.getAllSimpleConditions = (condition) => {
+    const simple = [];
+    if (Array.isArray(condition)) {
+      condition.forEach((c) => {
+        simple.push(..._getAllSimple(c));
+      });
+    } else {
+      simple.push(..._getAllSimple(condition));
+    }
+    return simple;
+  };
+})(Condition || (Condition = {}));
+
+// src/rules/rule.ts
+var Rule;
+((Rule2) => {
+  Rule2.isEmpty = (rule) => {
+    const emptyConditions = rule.all.length === 0 && rule.some.length === 0;
+    const emptyActions = rule.onSuccess.length === 0 && rule.onFailure.length === 0;
+    return emptyConditions || emptyActions;
+  };
+  Rule2.solve = (rule, facts) => {
+    if (rule.some.length === 0 && rule.all.length === 0) {
+      return false;
+    }
+    const someSolved = rule.some.map((condition) => Condition.evaluate(condition, facts));
+    const someResult = someSolved.length === 0 || someSolved.some(DUtil.isTrue);
+    const allSolved = rule.all.map((condition) => Condition.evaluate(condition, facts)).every(DUtil.isTrue);
+    return allSolved && someResult;
+  };
+})(Rule || (Rule = {}));
+
+// src/rules/rule-engine.ts
+var RuleEngine = class {
+  constructor() {
+  }
+  solveAll(rules, facts) {
+    const errors = [];
+    const matching = [];
+    rules.forEach((rule) => {
+      if (Rule.isEmpty(rule)) {
+        errors.push({ message: "Empty rule: " + rule.id });
+      } else if (Rule.solve(rule, facts)) {
+        const match = {
+          ruleDescription: rule.description,
+          matchingRuleId: rule.id ?? "no-id-given",
+          actionList: [...rule.onSuccess]
+        };
+        matching.push(match);
+      }
+    });
+    return { matching, errors };
+  }
+  solve(rule, facts) {
+    return Rule.solve(rule, facts);
+  }
+};
+
+// src/engine/next-que.ts
+var NextQue = class {
+  originalOrder = [];
+  allPages = [];
+  excludedTags = /* @__PURE__ */ new Set();
+  excludedByPageId = /* @__PURE__ */ new Set();
+  remaining = [];
+  constructor(pages = []) {
+    this.resetQue(pages);
+  }
+  /**
+   * Will reset que with the new pages.
+   * @param pages
+   */
+  resetQue(pages) {
+    this.allPages = [...pages];
+    this.remaining = [...pages];
+    this.excludedTags = /* @__PURE__ */ new Set();
+    this.excludedByPageId = /* @__PURE__ */ new Set();
+    this.originalOrder = this.allPages.map((p) => p.id);
+  }
+  pop() {
+    const next = this.remaining.shift();
+    return next ?? false;
+  }
+  peek() {
+    const next = this.remaining[0];
+    return next ?? false;
+  }
+  jumpToPageById(pageId) {
+    const index = this.remaining.findIndex((p) => p.id === pageId);
+    if (index < 0) {
+      return false;
+    }
+    this.remaining = this.remaining.slice(index);
+    return true;
+  }
+  removeByTag(tag) {
+    if (Array.isArray(tag)) {
+      tag.forEach((tag2) => {
+        this.excludedTags.add(tag2);
+      });
+    } else {
+      this.excludedTags.add(tag);
+    }
+    this.filterRemaining();
+  }
+  /**
+   * Will not be included
+   * @param pages
+   */
+  insertAsNextByForce(pages) {
+    this.remaining.unshift(...pages);
+  }
+  removeByPageId(pageId) {
+    if (Array.isArray(pageId)) {
+      pageId.forEach((id) => {
+        this.excludedByPageId.add(id);
+      });
+    } else {
+      this.excludedByPageId.add(pageId);
+    }
+    this.filterRemaining();
+  }
+  filterRemaining() {
+    this.remaining = this.remaining.filter((p) => {
+      const tags = p.tags ?? [];
+      const isIncluededByTag = !tags.some((tag) => this.excludedTags.has(tag));
+      const isIncludedByPageId = !this.excludedByPageId.has(p.id);
+      return isIncludedByPageId && isIncluededByTag;
+    });
+  }
+  get isEmpty() {
+    return this.remaining.length === 0;
+  }
+  /**
+   * Total number of pages left in que
+   */
+  get size() {
+    return this.remaining.length;
+  }
+  /**
+   * Total number of pages in test
+   */
+  get pageCount() {
+    return this.originalOrder.length;
+  }
+};
+
+// src/engine/dplayer.ts
+var DPlayer = class {
+  eventLog = [];
+  history = new HistoryQue();
+  ruleEngine = new RuleEngine();
+  nextQue = new NextQue();
+  data;
+  predefinedFacts;
+  constructor(data) {
+    this.data = data;
+    const pages = data.pages ?? [];
+    this.predefinedFacts = data.predefinedFacts ? [...data.predefinedFacts] : [];
+    this.nextQue.resetQue(pages);
+  }
+  saveEvent(event) {
+    this.eventLog.push(event);
+  }
+  saveHistory(pageHistory) {
+    this.history.addToHistory(pageHistory);
+    this.eventLog.push(...pageHistory.eventLog);
+    const userGeneratedFact = this.history.getFacts();
+    const predefinedFacts = this.predefinedFacts;
+    const facts = [...userGeneratedFact, ...predefinedFacts];
+    const result = this.ruleEngine.solveAll(this.data.rules, facts);
+    const matchingRules = result.matching;
+    const actions = matchingRules.map((r) => r.actionList).flat(1);
+    actions.forEach((a) => {
+      switch (a.kind) {
+        case "jumpToPage":
+          this.nextQue.jumpToPageById(a.pageId);
+          break;
+        case "excludeByPageId":
+          this.nextQue.removeByPageId(a.pageIds);
+          break;
+        case "excludeByTag":
+          this.nextQue.removeByTag(a.tagIds);
+          break;
+        default:
+          console.log("UNKNOWN ACTION", a);
+          const check = a;
+      }
+    });
+  }
+  getResults() {
+    const pagesLeft = this.nextQue.size;
+    const answerFacts = this.history.getFacts();
+    const predefinedFacts = this.predefinedFacts;
+    const eventLog = [...this.eventLog];
+    return { answerFacts, predefinedFacts, eventLog, pagesLeft };
+  }
+  insertSequence(sequenceId) {
+    this.insertSequenceById(sequenceId);
+  }
+  getNextPage() {
+    const next = this.nextQue.pop();
+    return next ?? false;
+  }
+  insertSequenceById(id) {
+    const seq = this.data.pageSequences?.find((s) => s.id === id);
+    if (seq) {
+      this.nextQue.insertAsNextByForce([...seq.pages]);
+    } else {
+    }
+  }
+  /**
+   * Total number of pages left in que
+   */
+  get pagesLeft() {
+    return this.nextQue.pageCount;
+  }
+  /**
+   * Total number of pages in test
+   */
+  get totalPageCount() {
+    return this.data.pages.length;
+  }
+};
+
+// src/engine/scale.ts
+var ScaleService = class {
+  baseHeight;
+  baseWidth;
+  containerHeight = 1300;
+  containerWidth = 1300;
+  get scale() {
+    return this._scale;
+  }
+  get pageHeight() {
+    return this.baseHeight * this.scale;
+  }
+  get pageWidth() {
+    return this.baseWidth * this._scale;
+  }
+  _scale = 1;
+  subscribers = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.baseHeight = config.baseHeight;
+    this.baseWidth = config.baseWidth;
+    this.containerHeight = config.containerHeight;
+    this.containerWidth = config.containerWidth;
+    this.updateScale();
+  }
+  setContainerBounds(bounds) {
+    this.containerWidth = bounds.width;
+    this.containerHeight = bounds.height;
+    this.updateScale();
+  }
+  updateScale() {
+    const scaleFn = Scale.calc(this.baseHeight, this.baseWidth);
+    const scale = scaleFn({ height: this.containerHeight, width: this.containerWidth });
+    const hasChanged = this.scale !== scale;
+    this._scale = scale;
+    if (hasChanged) {
+      this.subscribers.forEach((fn) => {
+        fn(this._scale);
+      });
+    }
+  }
+  onChange(scaleChangeHandler, subscriberId) {
+    this.subscribers.add(scaleChangeHandler);
+    scaleChangeHandler(this._scale);
+    return () => {
+      this.subscribers.delete(scaleChangeHandler);
+    };
+  }
+};
+var Scale;
+((Scale2) => {
+  Scale2.calc = (baseHeight, baseWidth) => {
+    return (container) => {
+      const heightRatio = container.height / baseHeight;
+      const widthRatio = container.width / baseWidth;
+      return Math.min(heightRatio, widthRatio);
+    };
+  };
+  Scale2.scaleFunctionCreator = (scale) => {
+    return (value) => value * scale;
+  };
+})(Scale || (Scale = {}));
+
+// src/Delement/css.ts
+var DCss;
+((DCss2) => {
+  DCss2.toString = (unit, scale) => {
+    const clampedScale = Math.max(scale, 0.03);
+    if (unit._unit === "px") {
+      if (unit.value < 0.1) {
+        return "0px";
+      }
+      const rounded = Math.round(unit.value * clampedScale);
+      const clamped = Math.max(rounded, 1);
+      return clamped + "px";
+    }
+    return unit.value + "%";
+  };
+  DCss2.isLengthUnit = (unit) => {
+    if (!unit) {
+      return false;
+    }
+    const unitKey = "_unit";
+    const valueKey = "value";
+    const hasUnitKey = DUtil.hasKey(unit, unitKey);
+    const hasValueKey = DUtil.hasKey(unit, valueKey);
+    return hasUnitKey && hasValueKey;
+  };
+})(DCss || (DCss = {}));
+
+// src/Delement/DStyle.ts
+var DStyle;
+((DStyle2) => {
+  DStyle2.normalize = (el) => {
+    el.style.padding = "0";
+    el.style.margin = "0";
+    el.style.position = "absolute";
+    el.style.boxSizing = "border-box";
+    return el;
+  };
+  DStyle2.applyStyles = (el, style, scale) => {
+    const {
+      x,
+      y,
+      backgroundColor,
+      borderColor,
+      borderWidth,
+      borderRadius,
+      borderStyle,
+      w,
+      opacity,
+      cursor,
+      fontSize,
+      fontWeight,
+      textColor,
+      textAlign,
+      translate,
+      margin,
+      padding,
+      letterSpacing,
+      h,
+      transform,
+      visibility
+    } = style;
+    if (backgroundColor) {
+      el.style.backgroundColor = backgroundColor;
+    }
+    if (cursor) {
+      el.style.cursor = cursor;
+    }
+    if (transform) {
+      el.style.transform = transform;
+    }
+    if (textColor) {
+      el.style.color = textColor;
+    }
+    if (textAlign) {
+      el.style.textAlign = textAlign;
+    }
+    if (borderColor) {
+      el.style.borderColor = borderColor;
+    }
+    if (borderWidth) {
+      el.style.borderWidth = DCss.toString(borderWidth, scale);
+    }
+    if (fontWeight) {
+      el.style.fontWeight = fontWeight + "";
+    }
+    if (borderStyle) {
+      el.style.borderStyle = borderStyle;
+    }
+    if (fontSize) {
+      el.style.fontSize = DCss.toString(fontSize, scale);
+    }
+    if (DUtil.isNumber(x)) {
+      el.style.left = x + "%";
+    }
+    if (DUtil.isNumber(y)) {
+      el.style.bottom = y + "%";
+    }
+    if (DUtil.isNumber(h)) {
+      el.style.height = h + "%";
+    }
+    if (DUtil.isNumber(w)) {
+      el.style.width = w + "%";
+    }
+    if (DCss.isLengthUnit(borderRadius)) {
+      el.style.borderRadius = DCss.toString(borderRadius, scale);
+    }
+    if (letterSpacing) {
+      el.style.letterSpacing = DCss.toString(letterSpacing, scale);
+    }
+    if (margin) {
+      el.style.margin = DCss.toString(margin, scale);
+    }
+    if (padding) {
+      el.style.padding = DCss.toString(padding, scale);
+    }
+    if (DUtil.isNumber(opacity)) {
+      el.style.opacity = opacity + "";
+    }
+    if (visibility) {
+      el.style.visibility = visibility;
+    }
+    return el;
+  };
+})(DStyle || (DStyle = {}));
+
+// src/Delement/DElement.ts
+var DElement = class {
+  constructor(el, dto, scale) {
+    this.el = el;
+    this.dto = dto;
+    this.scale = scale;
+    if (dto.innerText) {
+      this.el.innerText = dto.innerText;
+    }
+    this.setStyle = this.setStyle.bind(this);
+    this.normalize = this.normalize.bind(this);
+    this.appendYourself = this.appendYourself.bind(this);
+    this.updateStyles = this.updateStyles.bind(this);
+    const { onMouseEnter, onMouseLeave } = dto;
+    if (onMouseEnter) {
+      this.el.onmouseenter = () => {
+        this.setStyle(onMouseEnter);
+      };
+    }
+    if (onMouseLeave) {
+      this.el.onmouseleave = () => {
+        this.setStyle(onMouseLeave);
+      };
+    }
+    this.el.onclick = () => {
+      this.onclick();
+    };
+    this.normalize();
+    if (dto) {
+      this.updateStyles(dto?.style);
+    }
+  }
+  currStyle = {
+    fontSize: { _unit: "px", value: 100 },
+    fontWeight: 500,
+    textColor: "black",
+    opacity: 1
+  };
+  /**
+   *  This method is called when the element is clicked.
+   *  This method shall be overridden by the pageClass.
+   * @param actions
+   */
+  onclick() {
+  }
+  setStyle(style) {
+    this.updateStyles(style);
+  }
+  appendYourself(parent) {
+    parent.append(this.el);
+  }
+  normalize() {
+    this.el.style.padding = "0";
+    this.el.style.margin = "0";
+    this.el.style.position = "absolute";
+    this.el.style.boxSizing = "border-box";
+  }
+  updateStyles(style) {
+    this.currStyle = Object.assign(this.currStyle, style);
+    DStyle.applyStyles(this.el, this.currStyle, this.scale.scale);
+    window.getComputedStyle(this.el);
+  }
+};
+
+// src/Delement/Ddiv.ts
+var DDiv = class extends DElement {
+  TAG = "[ DDiv ]: ";
+  defaultStyle = { x: 22, y: 4 };
+  children = [];
+  constructor(dto, scale, children) {
+    const d = document.createElement("div");
+    super(d, dto, scale);
+    this.children = children;
+    this.children.forEach((child) => {
+      child.appendYourself(this.el);
+    });
+  }
+};
+
+// src/common/DTimestamp.ts
+var DTimestamp;
+((DTimestamp2) => {
+  DTimestamp2.now = () => Date.now();
+  DTimestamp2.addMills = (t, ms) => {
+    const res = t + Math.abs(ms);
+    return res;
+  };
+  DTimestamp2.diff = (t1, t2) => {
+    const t1Abs = Math.abs(t1);
+    const t2Abs = Math.abs(t2);
+    return Math.abs(t1Abs - t2Abs);
+  };
+  DTimestamp2.diffNow = (t) => {
+    return (0, DTimestamp2.diff)(t, (0, DTimestamp2.now)());
+  };
+})(DTimestamp || (DTimestamp = {}));
+
+// src/Delement/DImg.ts
+var DImg = class _DImg extends DElement {
+  constructor(dto, scaleService) {
+    super(document.createElement("img"), dto, scaleService);
+    this.dto = dto;
+    this.scaleService = scaleService;
+    _DImg.IMAGE_COUNT += 1;
+    this.imageCount = _DImg.IMAGE_COUNT;
+    this.TAG = "[D_IMG " + _DImg.IMAGE_COUNT + " ]: ";
+    this.TIMING_TAG = "load-time (" + _DImg.IMAGE_COUNT + ") ";
+    this.el.loading = "eager";
+    this.el.style.position = "absolute";
+    this.setStyle(dto.style);
+    this.loadStart = DTimestamp.now();
+    this.el.onload = () => {
+    };
+    this.el.onerror = () => {
+    };
+    this.el.src = dto.url;
+    console.time(this.TIMING_TAG);
+  }
+  static IMAGE_COUNT = 0;
+  imageCount;
+  TAG;
+  TIMING_TAG;
+  loadStart;
+  log() {
+  }
+};
+
+// src/Delement/DText.ts
+var DText = class extends DElement {
+  constructor(dto, scale) {
+    super(document.createElement("p"), dto, scale);
+  }
+};
+
+// src/Delement/element-factory.ts
+var createDElement = (dto, scale) => {
+  switch (dto._tag) {
+    case "div":
+      const childEls = createChildrenForDiv(dto, scale);
+      const newDiv = new DDiv(dto, scale, childEls);
+      return newDiv;
+    case "img":
+      return new DImg(dto, scale);
+    case "p":
+      return new DText(dto, scale);
+    default:
+      const check = dto;
+      throw new Error("Unknown dto given to the createDElement function.");
+  }
+};
+var createChildrenForDiv = (dto, scale) => {
+  const childDto = dto.children;
+  const childEls = [];
+  childDto.forEach((dto2) => {
+    if (dto2._tag === "p") {
+      const newText = new DText(dto2, scale);
+      childEls.push(newText);
+    }
+    if (dto2._tag === "img") {
+      const newImage = new DImg(dto2, scale);
+      childEls.push(newImage);
+    }
+  });
+  return childEls;
+};
+
+// src/Delement/button-click-action.ts
+var ButtonClickAction = {
+  describe: (a) => {
+    switch (a.kind) {
+      case "next-page":
+        return "go to next page";
+      case "play-video":
+        return "VideoId = " + a.task.videoId;
+      case "play-audio":
+        return "AudioId = " + a.task.audioId;
+      case "pause-video":
+        return "";
+      case "pause-audio":
+        return "";
+      case "submit-fact":
+        return a.fact.label + " = " + a.fact.value;
+      case "submit-form":
+        return "";
+      default:
+        const _exhaustiveCheck = a;
+        return "";
+    }
+  }
+};
+
+// src/page/task-state.ts
+var TaskState = {
+  eq: (a, b) => {
+    return a.audioIsPlaying === b.audioIsPlaying && a.isGifMode === b.isGifMode && a.videoIsPlaying === b.videoIsPlaying && a.blockFormInput === b.blockFormInput && a.blockResponseButton === b.blockResponseButton && a.blockAudio === b.blockAudio && a.blockVideo === b.blockVideo;
+  },
+  getDiff: (curr, prev) => {
+    if (prev === false) {
+      return curr;
+    }
+    const diff = {};
+    if (curr.audioIsPlaying !== prev.audioIsPlaying) {
+      diff.audioIsPlaying = curr.audioIsPlaying;
+    }
+    if (curr.isGifMode !== prev.isGifMode) {
+      diff.isGifMode = curr.isGifMode;
+    }
+    if (curr.videoIsPlaying !== prev.videoIsPlaying) {
+      diff.videoIsPlaying = curr.videoIsPlaying;
+    }
+    if (curr.blockFormInput !== prev.blockFormInput) {
+      diff.blockFormInput = curr.blockFormInput;
+    }
+    if (curr.blockResponseButton !== prev.blockResponseButton) {
+      diff.blockResponseButton = curr.blockResponseButton;
+    }
+    if (curr.blockAudio !== prev.blockAudio) {
+      diff.blockAudio = curr.blockAudio;
+    }
+    if (curr.blockVideo !== prev.blockVideo) {
+      diff.blockVideo = curr.blockVideo;
+    }
+    return diff;
+  }
+};
+
+// src/page/page-component.ts
+var isFalse = (bool) => bool === false;
+var isTrue = (bool) => bool === true;
+var PageComponent = class {
+  constructor(dto, scale) {
+    this.dto = dto;
+    this.scale = scale;
+    this.el = createDElement(dto.el, scale);
+    this.el.onclick = () => {
+      if (dto.onClick) {
+        this.onClick(dto.onClick);
+      } else {
+        console.warn(this.TAG + "onClick not implemented");
+      }
+    };
+  }
+  TAG = "[ PageComponent ]: ";
+  el;
+  prevState = false;
+  onClick(action) {
+    console.warn(this.TAG + "onclick not implemented");
+  }
+  updateState(state) {
+    this.handleStateChanges(state);
+  }
+  setState(state) {
+    const prev = this.prevState;
+    const diff = TaskState.getDiff(state, prev);
+    this.prevState = state;
+    if (Object.keys(diff).length > 0) {
+      this.handleStateChanges(diff);
+    }
+  }
+  handleStateChanges(diff) {
+    const {
+      videoIsPlaying,
+      audioIsPlaying,
+      blockAudio,
+      blockVideo,
+      blockResponseButton,
+      blockFormInput,
+      isGifMode
+    } = diff;
+    const {
+      whenAudioPaused,
+      whenVideoPaused,
+      whenAudioPlaying,
+      whenFormInputBlocked,
+      whenResponseBlocked,
+      whenVideoPlay,
+      whenAudioBlocked,
+      whenVideoBlocked,
+      whenAudioUnblocked,
+      whenVideoUnblocked,
+      whenResponseUnblocked,
+      whenFormInputUnblocked
+    } = this.dto;
+    if (isTrue(audioIsPlaying) && whenAudioPlaying) {
+      this.el.setStyle(whenAudioPlaying);
+    }
+    if (isFalse(audioIsPlaying) && whenAudioPaused) {
+      this.el.setStyle(whenAudioPaused);
+    }
+    if (isTrue(videoIsPlaying) && whenVideoPlay) {
+      this.el.setStyle(whenVideoPlay);
+    }
+    if (isFalse(videoIsPlaying) && whenVideoPaused) {
+      this.el.setStyle(whenVideoPaused);
+    }
+  }
+  appendToParent(parent) {
+    this.el.appendYourself(parent);
+  }
+};
+
+// src/events/mq-events.ts
+var MqEvent = {
+  engineStart(schemaId, schemaPrefix) {
+    return {
+      kind: "engine-start",
+      timestamp: DTimestamp.now(),
+      payload: { schemaId, schemaPrefix }
+    };
+  },
+  pageEnter(pageId, pagePrefix) {
+    return {
+      kind: "page-enter",
+      timestamp: DTimestamp.now(),
+      payload: { pageId, pagePrefix }
+    };
+  },
+  pageLeave(pageId, pagePrefix) {
+    return {
+      kind: "page-leave",
+      timestamp: DTimestamp.now(),
+      payload: { pageId, pagePrefix }
+    };
+  },
+  userClicked(data) {
+    const { pageId, pagePrefix, action, descriptions } = data;
+    return {
+      kind: "user-clicked",
+      timestamp: DTimestamp.now(),
+      payload: { pageId, pagePrefix, action, descriptions }
+    };
+  }
+};
+
+// src/page/Page.ts
+var PageDto = {
+  createDummy: (id) => {
+    return {
+      id: "id" + id,
+      prefix: "prefix" + id,
+      tags: [],
+      staticElements: [],
+      background: "white",
+      // videoList: [],
+      components: [
+        {
+          el: {
+            _tag: "div",
+            style: { x: 10, y: 0, w: 40, h: 20, backgroundColor: "red" },
+            children: [],
+            innerText: "Next btn " + id
+          }
+        }
+      ],
+      initialTasks: []
+    };
+  }
+};
+var Page = class {
+  constructor(dto, taskManager, scaleService, onCompleted) {
+    this.dto = dto;
+    this.taskManager = taskManager;
+    this.scaleService = scaleService;
+    this.onCompleted = onCompleted;
+    this.components = dto.components.map((el) => {
+      const component = new PageComponent(el, scaleService);
+      component.onClick = (action) => {
+        this.handleButtonAction(action);
+      };
+      this.components.push(component);
+      return component;
+    });
+    dto.staticElements.forEach((el) => {
+      const element = createDElement(el, scaleService);
+      this.staticElements.push(element);
+    });
+    if (dto.videoPlayer) {
+      this.taskManager.loadVideo(dto.videoPlayer.playUrl);
+      if (dto.videoPlayer.style) {
+        this.taskManager.setVideoStyles(dto.videoPlayer.style);
+      }
+    }
+    if (dto.initialTasks.length) {
+      this.taskManager.autoPlaySequence(dto.initialTasks);
+    }
+  }
+  TAG = "[ DPage ]: ";
+  staticElements = [];
+  components = [];
+  pageEntered = DTimestamp.now();
+  previousState = false;
+  eventLog = new Array();
+  createPageResult(facts) {
+    const pageExited = DTimestamp.now();
+    const pageTime = DTimestamp.diff(this.pageEntered, pageExited);
+    const pageExit = MqEvent.pageLeave(this.dto.id, this.dto.prefix);
+    this.eventLog.push(pageExit);
+    const eventLog = [...this.eventLog];
+    return {
+      pagePrefix: this.dto.prefix,
+      pageId: this.dto.id,
+      eventLog,
+      pageTime,
+      collectedFacts: facts
+    };
+  }
+  handleButtonAction(a) {
+    const event = MqEvent.userClicked({
+      pageId: this.dto.id,
+      pagePrefix: this.dto.prefix,
+      action: a.kind,
+      descriptions: ButtonClickAction.describe(a)
+    });
+    this.eventLog.push(event);
+    switch (a.kind) {
+      case "next-page":
+        const nextPageResult = this.createPageResult([]);
+        this.onCompleted(nextPageResult);
+        break;
+      case "play-video":
+        this.taskManager.execute(a.task);
+        break;
+      case "play-audio":
+        this.taskManager.execute(a.task);
+        break;
+      case "pause-video":
+        this.taskManager.pauseVideo();
+        break;
+      case "pause-audio":
+        this.taskManager.pauseAudio();
+        break;
+      case "submit-fact":
+        const submitFactResult = this.createPageResult([a.fact]);
+        this.onCompleted(submitFactResult);
+        break;
+      case "submit-form":
+        const submitFormResult = this.createPageResult([]);
+        this.onCompleted(submitFormResult);
+        break;
+      default:
+        const _exhaustiveCheck = a;
+        console.log(_exhaustiveCheck);
+    }
+  }
+  appendYourself(parent) {
+    const pageEnterEvent = MqEvent.pageEnter(this.dto.id, this.dto.prefix);
+    this.pageEntered = DTimestamp.now();
+    this.eventLog.push(pageEnterEvent);
+    this.staticElements.forEach((el) => {
+      el.appendYourself(parent);
+    });
+    this.components.forEach((comp) => {
+      comp.appendToParent(parent);
+    });
+  }
+  destroy() {
+    this.taskManager.clear();
+  }
+  tick() {
+    const prev = this.previousState;
+    const curr = this.taskManager.getState();
+    const diff = TaskState.getDiff(curr, prev);
+    this.components.forEach((comp) => {
+      comp.updateState(diff);
+    });
+  }
+};
+
+// src/page/task.ts
+var eq = (a, b) => {
+  if (!b) {
+    return false;
+  }
+  if (a.kind !== b.kind) {
+    return false;
+  }
+  if (a.kind === "delay-task" && b.kind === "delay-task") {
+    return a.duration === b.duration;
+  }
+  if (a.kind === "play-audio-task" && b.kind === "play-audio-task") {
+    return a.url === b.url && a.audioId === b.audioId;
+  }
+  if (a.kind === "play-video-task" && b.kind === "play-video-task") {
+    return a.url === b.url && a.videoId === b.videoId && a.startAt === b.startAt && a.stopAt === b.stopAt && a.volume === b.volume;
+  }
+  return false;
+};
+var deleteTaskList = (task) => {
+  return task.priority === "replace-all" || task.priority === "replace-queue";
+};
+var shallRemoveCurrent = (task) => {
+  return task.priority === "replace-current" || task.priority === "replace-all";
+};
+var notEq = (a, b) => !eq(a, b);
+var is = (task) => {
+  if (!task) {
+    return false;
+  }
+  if (typeof task !== "object") {
+    return false;
+  }
+  if (Array.isArray(task)) {
+    return false;
+  }
+  return true;
+};
+var Task = {
+  eq,
+  is,
+  notEq,
+  deleteTaskList,
+  shallRemoveCurrent
+};
+
+// src/page/task-manager.ts
+var TaskManager = class {
+  constructor(mediaLayer, scale, onError) {
+    this.mediaLayer = mediaLayer;
+    this.scale = scale;
+    this.onError = onError;
+    this.hideVideo();
+    this.mediaLayer.appendChild(this.videoElement);
+    this.mediaLayer.appendChild(this.audioElement);
+    DStyle.normalize(this.videoElement);
+    DStyle.applyStyles(this.videoElement, this.videoStyles, this.scale.scale);
+    this.videoElement.onended = () => {
+      const next = this.getNextTask();
+      if (next) {
+        this.execute(next);
+      } else {
+        this.runningTask = false;
+      }
+    };
+    this.videoElement.onerror = (e) => {
+      if (this.videoElement.src !== "") {
+        onError("Error playing video: " + this.videoElement.src);
+      }
+    };
+    this.audioElement.onended = () => {
+      const next = this.getNextTask();
+      if (next) {
+        this.execute(next);
+      } else {
+        this.runningTask = false;
+      }
+    };
+  }
+  TAG = "[TaskManager]: ";
+  videoElement = document.createElement("video");
+  audioElement = document.createElement("audio");
+  showConsoleLogs = false;
+  videoStyles = {
+    h: 40,
+    w: 80,
+    y: 60,
+    x: 10
+  };
+  runningTask = false;
+  taskList = [];
+  delayRef = false;
+  clear() {
+    if (this.showConsoleLogs)
+      console.log(this.TAG + "CLEAR");
+    if (typeof this.delayRef === "number") {
+      window.clearTimeout(this.delayRef);
+    }
+    this.pauseVideo();
+    this.pauseAudio();
+    this.videoElement.removeAttribute("src");
+    this.videoElement.load();
+    this.audioElement.removeAttribute("src");
+    this.audioElement.load();
+    this.taskList = [];
+    this.runningTask = false;
+    this.hideVideo();
+  }
+  getState() {
+    const c = this.runningTask;
+    const isGifMode = this.videoElement.loop;
+    const audioIsPlaying = c && c.task.kind === "play-audio-task" && !this.audioElement.paused;
+    const videoIsPlaying = c && c.task.kind === "play-video-task" && !this.videoElement.paused;
+    const blockResponseButton = c && c.task.blockResponseButton;
+    const blockAudio = c && c.task.blockAudio;
+    const blockVideo = c && c.task.blockVideo;
+    const blockFormInput = c && c.task.blockFormInput;
+    return {
+      audioIsPlaying,
+      isGifMode,
+      videoIsPlaying,
+      blockFormInput,
+      blockResponseButton,
+      blockAudio,
+      blockVideo
+    };
+  }
+  execute(task) {
+    const curr = this.runningTask;
+    let isBackgroundTask = false;
+    if (curr && Task.shallRemoveCurrent(task) && Task.notEq(curr.task, task)) {
+      this.pauseAudio();
+      this.pauseVideo();
+      this.runningTask = false;
+    }
+    if (!curr) {
+      this.runningTask = { startedAt: DTimestamp.now(), task };
+    } else if (Task.notEq(curr.task, task)) {
+      this.runningTask = { startedAt: DTimestamp.now(), task };
+    }
+    if (task.priority === "replace-all" || task.priority === "replace-queue") {
+      this.taskList = [];
+    }
+    if (task.kind === "play-video-task") {
+      this.showVideo();
+      this.loadVideo(task.url);
+      if (task.loop) {
+        this.videoElement.loop = true;
+        isBackgroundTask = true;
+      } else {
+        this.videoElement.loop = false;
+      }
+      try {
+        this.videoElement.play();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    if (task.kind === "play-audio-task") {
+      if (!this.videoElement.loop) {
+        this.pauseVideo();
+      }
+      if (task.url !== this.audioElement.src) {
+        this.audioElement.src = task.url;
+      }
+      this.audioElement.play();
+    }
+    if (task.kind === "delay-task") {
+      if (typeof this.delayRef === "number") {
+        window.clearTimeout(this.delayRef);
+      }
+      this.delayRef = window.setTimeout(() => {
+        const next = this.getNextTask();
+        if (next) {
+          this.execute(next);
+        } else {
+          this.runningTask = false;
+        }
+      }, task.duration);
+    }
+    if (isBackgroundTask) {
+      const startNextTask = this.getNextTask();
+      if (startNextTask) {
+        this.execute(startNextTask);
+      }
+    }
+    return true;
+  }
+  setVideoStyles(styles) {
+    this.videoStyles = styles;
+    DStyle.applyStyles(this.videoElement, this.videoStyles, this.scale.scale);
+  }
+  autoPlaySequence(tasks) {
+    this.taskList = [...tasks];
+    const next = this.getNextTask();
+    if (next) {
+      this.execute(next);
+      if (next.kind === "play-video-task" && next.loop) {
+        this.videoElement.loop = true;
+      }
+    }
+  }
+  loadVideo(url) {
+    if (this.videoElement.src !== url) {
+      this.videoElement.src = url;
+    }
+    this.showVideo();
+  }
+  playVideoElement() {
+    this.videoElement.play().then(() => {
+    }).catch((e) => {
+      console.log(e);
+      this.onError("Error playing video.");
+    });
+  }
+  showVideo() {
+    this.videoElement.style.display = "block";
+  }
+  hideVideo() {
+    this.videoElement.style.display = "none";
+  }
+  pauseVideo() {
+    try {
+      if (!this.videoElement.loop) {
+        this.videoElement.pause();
+      }
+    } catch (e) {
+      console.log(e);
+      this.onError("Error pausing video.");
+    }
+  }
+  pauseAudio() {
+    try {
+      if (!this.audioElement.loop) {
+        this.audioElement.pause();
+      }
+    } catch (e) {
+      console.log(e);
+      this.onError("Error pausing audio.");
+    }
+  }
+  getNextTask() {
+    console.log("Getting next task.");
+    const first = this.taskList.shift();
+    return first ?? false;
+  }
+};
+
+// src/engine/SchemaEngine.ts
+var voidLogger = {
+  info: (message) => {
+  },
+  error: (message) => {
+  },
+  warn: (message) => {
+  }
+};
+var SchemaEngine = class {
+  constructor(hostEl, height, width, schema) {
+    this.height = height;
+    this.width = width;
+    this.schema = schema;
+    this.tickerRef = window.setInterval(() => {
+      if (this.currentPage) {
+        this.currentPage.tick();
+      }
+    }, 100);
+    this.hostElement = hostEl;
+    this.hostElement.appendChild(this.mediaLayer);
+    this.hostElement.appendChild(this.uiLayer);
+    this.scale = new ScaleService({
+      baseHeight: schema.baseHeight,
+      baseWidth: schema.baseWidth,
+      containerWidth: width,
+      containerHeight: height
+    });
+    this.logger.info(this.TAG + "Scale: " + JSON.stringify(this.scale));
+    this.player = new DPlayer(this.schema);
+    this.taskManager = new TaskManager(this.mediaLayer, this.scale, (error) => {
+      console.log(error);
+    });
+    this.styleSelf();
+    this.handlePageCompleted = this.handlePageCompleted.bind(this);
+    this.nextPage();
+  }
+  TAG = "[ SCHEMA_ENGINE ] :";
+  scale;
+  hostElement;
+  taskManager;
+  logger = voidLogger;
+  uiLayer = document.createElement("div");
+  mediaLayer = document.createElement("div");
+  player;
+  currentPage = false;
+  tickerRef = false;
+  handlePageCompleted(result) {
+    this.player.saveHistory(result);
+    const currentResults = this.player.getResults();
+    const a = {
+      schemaId: this.schema.id,
+      pagesLeft: currentResults.pagesLeft,
+      predefinedFacts: currentResults.predefinedFacts,
+      eventLog: currentResults.eventLog,
+      answers: currentResults.answerFacts
+    };
+    if (this._onProgress) {
+      this._onProgress(a);
+    }
+    this.nextPage();
+  }
+  styleSelf() {
+    this.hostElement.style.height = this.scale.pageHeight + "px";
+    this.hostElement.style.width = this.scale.pageWidth + "px";
+    this.hostElement.style.backgroundColor = this.schema.backgroundColor ?? "white";
+    this.hostElement.style.position = "relative";
+    const makeStatic = (div) => {
+      div.style.height = "0px";
+      div.style.width = "0px";
+      div.style.position = "static";
+    };
+    makeStatic(this.uiLayer);
+    this.uiLayer.style.zIndex = "10";
+    this.mediaLayer.style.zIndex = "8";
+    makeStatic(this.mediaLayer);
+  }
+  nextPage() {
+    const nextPage = this.player.getNextPage();
+    if (this.currentPage) {
+      this.currentPage.destroy();
+      this.uiLayer.innerHTML = "";
+    }
+    if (!nextPage) {
+      this.player = new DPlayer(this.schema);
+      if (this.player.pagesLeft > 0) {
+        this.nextPage();
+      }
+      return false;
+    }
+    const newPage = new Page(nextPage, this.taskManager, this.scale, (result) => {
+      this.handlePageCompleted(result);
+    });
+    this.currentPage = newPage;
+    newPage.appendYourself(this.uiLayer);
+    return true;
+  }
+  destroy() {
+    if (this.currentPage) {
+      this.currentPage.destroy();
+      this.uiLayer.innerHTML = "";
+    }
+  }
+  _onProgress = false;
+  onProgress(handler) {
+    this._onProgress = handler;
+  }
+  _onFatalError = false;
+  onFatalError(handler) {
+    this._onFatalError = handler;
+  }
+  setLogger(logger) {
+    this.logger = logger;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ButtonClickAction,
+  Condition,
+  DCss,
+  DDiv,
+  DElement,
+  DImg,
+  DStyle,
+  DText,
+  DUtil,
+  MqEvent,
+  PageComponent,
+  PageDto,
+  Rule,
+  RuleEngine,
+  SchemaEngine,
+  Task
+});
+//# sourceMappingURL=public-api.js.map