@media-quest/builder 0.0.1 → 0.0.3

package/src/Builder-schema.ts

@@ -0,0 +1,250 @@
+import type { BuilderPageDto, BuilderPageType } from "./Builder-page";
+import { BuilderPage } from "./Builder-page";
+import { RuleInput } from "./rulebuilder/RuleInput";
+import type { QuestionVariable } from "./rulebuilder/RuleVariable";
+import type { CustomVariable } from "./rulebuilder";
+import type { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./rulebuilder";
+import type { BuilderTagDto } from "./BuilderTag";
+import { BuilderTag, TagCollection } from "./BuilderTag";
+import type { BuilderRuleDto } from "./rulebuilder";
+import { BuilderRule } from "./rulebuilder";
+import { DefaultThemeCompiler } from "./theme/default-theme-compiler";
+import { ImageFile } from "./media-files";
+import { SchemaDto, DUtil } from "@media-quest/engine";
+const U = DUtil;
+// type SchemaHash = string & { __MD5__HASH: true };
+export interface BuilderSchemaDto {
+  readonly id: string;
+  readonly prefix: string;
+  readonly mainImage: ImageFile | false;
+  readonly backgroundColor: string;
+  readonly name: string;
+  readonly pages: BuilderPageDto[];
+  readonly baseHeight: number;
+  readonly baseWidth: number;
+  readonly rules: ReadonlyArray<BuilderRuleDto>;
+  readonly tags: ReadonlyArray<BuilderTagDto>;
+}
+
+export interface SchemaBuildOutput {
+  schema: SchemaDto;
+  codebook: Record<string, string>;
+  schemaConfig: Record<string, string>;
+}
+
+export class BuilderSchema {
+  baseHeight = 1300;
+  baseWidth = 1024;
+  backgroundColor = "#000000";
+  pages: BuilderPage[] = [];
+  mainImage: ImageFile | false = false;
+  private _rules: BuilderRule[] = [];
+  get rules(): ReadonlyArray<BuilderRule> {
+    return [...this._rules];
+  }
+
+  private readonly _tagCollection: TagCollection = TagCollection.create();
+  get tags(): ReadonlyArray<BuilderTag> {
+    return [...this._tagCollection];
+  }
+  public static create(id: string, name: string, prefix: string) {
+    return new BuilderSchema(id, name, prefix);
+  }
+
+  public static fromJson(dto: BuilderSchemaDto): BuilderSchema {
+    const schema = new BuilderSchema(dto.id, dto.name, dto.prefix);
+    const pages = dto.pages.map(BuilderPage.fromJson);
+    schema._tagCollection.init(dto.tags);
+    schema.backgroundColor = dto.backgroundColor;
+    schema.baseHeight = dto.baseHeight;
+    schema.baseWidth = dto.baseWidth;
+    schema.pages = pages;
+    schema.backgroundColor = dto.backgroundColor;
+    schema.mainImage = dto.mainImage ?? false;
+    const rulesDto = dto.rules ?? [];
+    const ruleInput = schema.getRuleInput();
+    schema._rules = rulesDto.map((r) => BuilderRule.fromDto(r, ruleInput));
+    return schema;
+  }
+
+  toJson(): BuilderSchemaDto {
+    const pages = this.pages.map((p) => p.toJson());
+    const tags = this._tagCollection.toJson();
+    const rules = this._rules.map((rule) => rule.toJson());
+
+    const dto: BuilderSchemaDto = {
+      backgroundColor: this.backgroundColor,
+      baseHeight: this.baseHeight,
+      baseWidth: this.baseWidth,
+      id: this.id,
+      name: this.name,
+      pages,
+      rules,
+      tags,
+      mainImage: this.mainImage,
+      prefix: this.prefix,
+    };
+    return dto;
+  }
+  private constructor(
+    public readonly id: string,
+    public name: string,
+    public prefix: string,
+  ) {}
+
+  addPage(type: BuilderPageType, atIndex = -1): BuilderPage {
+    const newPage = BuilderPage.create(type, "");
+    if (atIndex >= 0 && atIndex < this.pages.length) {
+      this.pages.splice(atIndex, 0, newPage);
+    } else {
+      this.pages.push(newPage);
+    }
+    return newPage;
+  }
+
+  insertPage(page: BuilderPage, atIndex: number): boolean {
+    return this.insertPageAtIndex(page, atIndex);
+  }
+
+  private insertPageAtIndex(page: BuilderPage, atIndex: number) {
+    const isValidIndex = U.isInRange(0, this.pages.length - 1);
+    if (!isValidIndex(atIndex)) {
+      return false;
+    }
+    const exists = !!this.pages.find((p) => p.id === page.id);
+    if (exists) {
+      return false;
+    }
+    this.pages.splice(atIndex, 0, page);
+    return true;
+  }
+
+  addRule() {
+    const input = this.getRuleInput();
+    const count = this._rules.length + 1;
+    const name = "Rule-number: " + count;
+    const rule = BuilderRule.fromDto(
+      {
+        conditions: [],
+        type: "all",
+        name,
+        excludeTags: [],
+        jumpToPage: false,
+        excludePages: [],
+      },
+      input,
+    );
+    this._rules.push(rule);
+  }
+  deleteRule(rule: BuilderRule) {
+    this._rules = this._rules.filter((r) => r !== rule);
+  }
+
+  movePage(page: BuilderPage, toIndex: number): boolean {
+    const index = this.pages.indexOf(page);
+    if (index < 0) {
+      return false;
+    }
+    const isValidIndex = U.isInRange(0, this.pages.length - 1);
+    if (!isValidIndex(toIndex)) {
+      return false;
+    }
+    // console.log('Moving from :' + index + ' to: ' + toIndex);
+    this.pages.splice(index, 1);
+    this.pages.splice(toIndex, 0, page);
+    return true;
+  }
+
+  deletePage(page: BuilderPage): boolean {
+    const filtered = this.pages.filter((p) => p !== page);
+    const didDelete = filtered.length === this.pages.length - 1;
+    this.pages = filtered;
+    return didDelete;
+  }
+
+  reevaluateRules() {
+    console.log("Reevaluationg rulesInput");
+    const input = this.getRuleInput();
+    const rulesDto = this._rules.map((r) => r.toJson());
+    this._rules = rulesDto.map((dto) => BuilderRule.fromDto(dto, input));
+  }
+
+  getRuleInput(): RuleInput {
+    const qVars: QuestionVariable[] = [];
+    const cVars: CustomVariable[] = [];
+    const pageIdActions: ExcludeByPageAction[] = [];
+    const tagActions: ExcludeByTagAction[] = this.tags.map((t) => {
+      const tag = t.tagText;
+      const pageCount = this.pages.reduce((count, curr) => {
+        return curr.tags.includes(tag) ? count + 1 : count;
+      }, 0);
+      const excludeByTagDto: ExcludeByTagAction = {
+        kind: "exclude-by-tag",
+        pageCount,
+        tag,
+        description: t.tagDescription,
+      };
+      return excludeByTagDto;
+    });
+    const jumpActions: JumpToPageAction[] = [];
+    const prefix = "";
+    this.pages.forEach((page, index) => {
+      const pageVariables = page.getQuestionVariables(prefix, index);
+      qVars.push(...pageVariables);
+      const pageId = page.prefix;
+      const mainText = page.mainText.text;
+      const jumpAction: JumpToPageAction = {
+        kind: "jump-to-page",
+        pageId: pageId,
+        pageNumber: index,
+        mainText: page.mainText.text,
+      };
+      const excludePageAction: ExcludeByPageAction = {
+        kind: "exclude-by-pageId",
+        pageId,
+        pageNumber: index,
+        mainText,
+      };
+      jumpActions.push(jumpAction);
+      pageIdActions.push(excludePageAction);
+    });
+    const ruleInput = new RuleInput(qVars, cVars, pageIdActions, tagActions, jumpActions);
+
+    return ruleInput;
+  }
+
+  deleteTags(tags: ReadonlyArray<BuilderTag>) {
+    this._tagCollection.deleteAll(tags);
+  }
+
+  addTag(builderTag: BuilderTag) {
+    this._tagCollection.add(builderTag);
+  }
+
+  // getHash(): SchemaHash {
+  //     const md5 = MD5(this.toJson());
+  //     return
+  // }
+
+  // hasChanged(hash: SchemaHash): boolean {
+  //     return hash !== this.getHash();
+  // }
+
+  private getQuestionVariables(withModulePrefix = false): ReadonlyArray<QuestionVariable> {
+    const prefix = withModulePrefix ? this.prefix : "";
+    const all = this.pages
+      .map((page, index) => {
+        return page.getQuestionVariables(prefix, index);
+      })
+      .flat(1);
+    return all;
+  }
+
+  compile(): SchemaBuildOutput {
+    const moduleDto = this.toJson();
+    const imp = new DefaultThemeCompiler();
+    const schema = imp.compile(moduleDto);
+
+    return { codebook: {}, schema, schemaConfig: {} };
+  }
+}

package/src/Builder-text.spec.ts

@@ -0,0 +1,24 @@
+import type { BuilderTextDto } from "./Builder-text";
+import { BuilderText } from "./Builder-text";
+import type { BuilderObjectId } from "./BuilderObject";
+
+const textDto: BuilderTextDto = {
+    id: "dto1" as BuilderObjectId.TextID,
+    name: "dto1-name",
+    text: "text one",
+    translationRequired: true,
+};
+
+let text1 = BuilderText.create("text one created");
+
+beforeEach(() => {
+    text1 = BuilderText.create("text one created");
+});
+
+describe("Builder Text", () => {
+    test("Can serialize", () => {
+        const instance1 = BuilderText.fromJson(textDto);
+        const json = instance1.toJson();
+        expect(textDto).toStrictEqual(json);
+    });
+});

package/src/Builder-text.ts

@@ -0,0 +1,57 @@
+import { BuilderObjectId, BuilderObject } from './BuilderObject';
+
+export interface BuilderTextDto {
+  readonly id: BuilderObjectId.TextID;
+  text: string;
+  name: string;
+  translationRequired: boolean;
+}
+
+export class BuilderText extends BuilderObject<'builder-text', BuilderTextDto> {
+  readonly objectType = 'builder-text';
+  id: BuilderObjectId.TextID;
+  text = '';
+  name = '';
+  translateRequired = false;
+  // audio: {id: B}
+  private constructor(dto: BuilderTextDto) {
+    super(dto);
+    this.id = dto.id;
+    this.translateRequired = dto.translationRequired;
+    this.name = dto.name;
+    this.text = dto.text;
+  }
+
+  public static create(name: string) {
+    const id = BuilderObjectId.textId();
+    const dto: BuilderTextDto = {
+      id,
+      name,
+      text: '',
+      translationRequired: false
+    };
+    const instance = new BuilderText(dto);
+    return instance;
+  }
+  public static fromJson(dto: BuilderTextDto) {
+    const instance = new BuilderText(dto);
+    return instance;
+  }
+
+  clone(): BuilderTextDto {
+    const newId = BuilderObjectId.textId();
+    const dto = this.toJson();
+    const withNewId: BuilderTextDto = { ...dto, id: newId };
+    return withNewId;
+  }
+
+  toJson(): BuilderTextDto {
+    const dto: BuilderTextDto = {
+      id: this.id,
+      name: this.name,
+      text: this.text,
+      translationRequired: this.translateRequired
+    };
+    return dto;
+  }
+}

package/src/BuilderMainImageDto.ts

@@ -0,0 +1,7 @@
+import { ImageFile } from "./media-files";
+
+export interface BuilderMainImageDto {
+    readonly kind: "main-image";
+    readonly file: ImageFile;
+    readonly overlay: { text: string; fontsize: number; xPos: number; yPos: number } | false;
+}

package/src/BuilderMainText.ts

@@ -0,0 +1,81 @@
+import { BuilderObject } from "./BuilderObject";
+import { AudioFile } from "./media-files";
+
+export interface BuilderMainTextDto {
+    text: string;
+    audioFile: AudioFile | false;
+    autoplay: boolean;
+    autoplayDelay: number;
+}
+
+export class BuilderMainText extends BuilderObject<"builder-main-text", BuilderMainTextDto> {
+    readonly objectType: "builder-main-text" = "builder-main-text";
+    autoplay = false;
+    private _audioFile: AudioFile | false = false;
+    autoplayDelay = 0;
+
+    text = "";
+
+    private constructor(dto: BuilderMainTextDto) {
+        super(dto);
+        this._audioFile = dto.audioFile ?? false;
+        this.autoplay = dto.autoplay ?? false;
+        this.autoplayDelay = dto.autoplayDelay ?? 0;
+        this.text = dto.text ?? "";
+    }
+
+    get autoplayDelayInSeconds() {
+        const delay = this.autoplayDelay;
+        const s = delay / 1000;
+        const formatted = s.toFixed(1);
+        return formatted;
+    }
+
+    get durationTag() {
+        if (!this.audioFile) return "";
+        // console.log(this.audioFile.duration);
+        const dur = this.audioFile.duration.toFixed(1);
+        return "dur " + dur + " s";
+    }
+
+    static fromJson(dto: BuilderMainTextDto): BuilderMainText {
+        const mainText = new BuilderMainText(dto);
+        return mainText;
+    }
+
+    static create = () => {
+        const dto: BuilderMainTextDto = {
+            autoplay: false,
+            autoplayDelay: 0,
+            audioFile: false,
+            text: "",
+        };
+        return new BuilderMainText(dto);
+    };
+
+    clone(): BuilderMainTextDto {
+        const dto = this.toJson();
+        const clone = JSON.parse(JSON.stringify(dto));
+        return clone;
+    }
+
+    toJson(): BuilderMainTextDto {
+        const dto: BuilderMainTextDto = {
+            text: this.text,
+            audioFile: this.audioFile,
+            autoplay: this.autoplay,
+            autoplayDelay: this.autoplayDelay,
+        };
+        return dto;
+    }
+    get audioFile(): AudioFile | false {
+        return this._audioFile;
+    }
+    set audioFile(audioFile: AudioFile | false) {
+        if (audioFile === false) {
+            this.autoplayDelay = 0;
+            this.autoplay = false;
+        }
+        this._audioFile = audioFile;
+    }
+}

package/src/BuilderMainVideoDto.ts

@@ -0,0 +1,10 @@
+import { VideoFile } from "./media-files";
+
+export interface BuilderMainVideoDto {
+    readonly kind: "main-video";
+    readonly file: VideoFile;
+    mode: "autoplay" | "required" | "optional";
+    preDelay: number;
+    volume: number;
+    controls: boolean;
+}

package/src/BuilderObject.ts

@@ -0,0 +1,69 @@
+import { DUtil } from "@media-quest/engine";
+
+const U = DUtil;
+/**
+ * Builder objects are complex objects that are embedded inside
+ * a Builder-schema, and needs to be serialized to json. Often these objects
+ * are used in collections, and that is why most of them need an id.
+ */
+type BuilderObjectType =
+  | "builder-page"
+  | "builder-question-option"
+  | "builder-question"
+  | "builder-main-text"
+  | "builder-text"
+  | "builder-rule"
+  | "builder-tag"
+  | "builder-condition"
+  | "builder-variable"
+  | "builder-condition-group";
+
+export namespace BuilderObjectId {
+  export type QuestionOptionID = string & { __OPTION__ID__: true };
+  export type QuestionID = string & { __QUESTION__ID__: true };
+  export type VideoFileID = string & { __VIDEO__ID__: true };
+  export type AudioFileID = string & { __AUDIO__ID__: true };
+  export type ImageID = string & { __IMAGE__ID__: true };
+  export type TextID = string & { __TEXT__ID__: true };
+  export type MainTextID = string & { __MAIN__TEXT__ID__: true };
+  export type PageID = string & { __PAGE__ID__: true };
+  export type TagId = string & { __TAG__ID__: true };
+
+  export const createTagId = (): TagId => {
+    return createId("builder-tag") as TagId;
+  };
+
+  export const mainTextId = (): MainTextID => {
+    return createId("builder-main-text") as MainTextID;
+  };
+  export const textId = (): TextID => {
+    return createId("builder-text") as TextID;
+  };
+
+  export const questionOptionId = (): QuestionOptionID => {
+    return createId("builder-question-option") as QuestionOptionID;
+  };
+  export const questionId = (): QuestionID => {
+    return createId("builder-question") as QuestionID;
+  };
+  export const pageId = (): PageID => {
+    return createId("builder-page") as PageID;
+  };
+
+  const createId = (type: BuilderObjectType): string => {
+    const id = U.randomString(24);
+    return type + "-" + id;
+  };
+}
+
+export abstract class BuilderObject<T extends BuilderObjectType, Dto extends {}> {
+  // abstract readonly id: string;
+  abstract readonly objectType: T;
+  abstract toJson(): Dto;
+  abstract clone(): Dto;
+  protected readonly originalDto: Dto;
+  protected constructor(dto: Dto) {
+    this.originalDto = dto;
+    // this.objectId = dto.objectId;
+  }
+}

package/src/BuilderTag.ts

@@ -0,0 +1,97 @@
+import { BuilderObjectId, BuilderObject } from './BuilderObject';
+
+export interface BuilderTagDto {
+  readonly id: BuilderObjectId.TagId;
+  readonly tag: string;
+  readonly description: string;
+}
+
+export class BuilderTag extends BuilderObject<'builder-tag', BuilderTagDto> {
+  readonly objectType: 'builder-tag' = 'builder-tag';
+  readonly id: BuilderObjectId.TagId;
+  tagText = '';
+  tagDescription = '';
+  public static readonly MAX_LENGTH = 20;
+  public static readonly MIN_LENGTH = 1;
+
+  public static readonly create = (tag: string, description: string = '') => {
+    const id = BuilderObjectId.createTagId();
+    const dto: BuilderTagDto = {
+      id,
+      tag,
+      description
+    };
+    return new BuilderTag(dto);
+  };
+  public static readonly fromDto = (dto: BuilderTagDto) => {
+    return new BuilderTag(dto);
+  };
+  protected constructor(dto: BuilderTagDto) {
+    const id = dto.id ?? BuilderObjectId.createTagId();
+    const withId = { ...dto, id };
+    super(withId);
+    this.id = id;
+    this.tagText = dto.tag ?? '';
+    this.tagDescription = dto.description ?? '';
+  }
+  clone(): BuilderTagDto {
+    return this.toJson();
+  }
+
+  toJson(): BuilderTagDto {
+    return { tag: this.tagText, description: this.tagDescription, id: this.id };
+  }
+}
+
+export class TagCollection implements Iterable<BuilderTag> {
+  private readonly _tags = new Set<BuilderTag>();
+  public static readonly create = () => {
+    return new TagCollection([]);
+  };
+
+  [Symbol.iterator]() {
+    const list = [...this._tags];
+    return list[Symbol.iterator]();
+  }
+  private constructor(initialTags: ReadonlyArray<BuilderTag>) {
+    initialTags.forEach(tag => {
+      this._tags.add(tag);
+    });
+  }
+
+  init(tags: ReadonlyArray<BuilderTagDto>) {
+    const dtoList: ReadonlyArray<BuilderTagDto> = Array.isArray(tags)
+      ? tags
+      : [];
+    const all = dtoList.map(BuilderTag.fromDto);
+    all.forEach(tag => {
+      this._tags.add(tag);
+    });
+  }
+
+  add(tag: BuilderTag) {
+    this._tags.add(tag);
+  }
+
+  /**
+   * Delete this tag from collection;
+   * @param tag
+   */
+  delete(tag: BuilderTag) {
+    this._tags.delete(tag);
+  }
+
+  toJson(): ReadonlyArray<BuilderTagDto> {
+    const list = [...this._tags];
+    const dtoList = list.map(t => t.toJson());
+    return dtoList;
+  }
+
+  deleteAll(tags: Iterable<BuilderTag>) {
+    const l = tags[Symbol.iterator]();
+    const asList = [...tags];
+    asList.forEach(t => {
+      this.delete(t);
+    });
+  }
+}

package/src/media-files.ts

@@ -0,0 +1,28 @@
+export interface AudioFile {
+    readonly kind: "audio-file";
+    readonly id: string;
+    readonly downloadUrl: string;
+    readonly duration: number;
+    readonly originalFileName: string;
+    readonly name: string;
+    readonly size: number;
+}
+
+export interface VideoFile {
+    readonly kind: "video-file";
+    readonly id: string;
+    readonly downloadUrl: string;
+    readonly duration: number;
+    readonly name: string;
+    readonly size: number;
+    readonly type: string;
+    readonly originalFileName: string;
+}
+export interface ImageFile {
+    readonly kind: "image-file";
+    readonly id: string;
+    readonly downloadUrl: string;
+    readonly name: string;
+    readonly size: number;
+    readonly type: string;
+}

package/src/public-api.ts

@@ -1,6 +1,13 @@
-import {createEngine} from "@media-quest/engine";
-export const logBuilder = () =>  {
-  const engine = createEngine();
-  console.log(engine.innerText);;
-  console.log("HELLO FROM BUILDER!! I Have imported engine with innerText: " + engine.innerText)
-}
+export { type BuilderOptionDto, BuilderOption } from "./Builder-option";
+export { type BuilderPageDto, type BuilderPageType, BuilderPage } from "./Builder-page";
+export { type BuilderQuestionDto, BuilderQuestion, type BuilderQuestionType } from "./Builder-question";
+export { BuilderSchema, type BuilderSchemaDto } from "./Builder-schema";
+export { BuilderText, type BuilderTextDto } from "./Builder-text";
+export { type BuilderMainImageDto } from "./BuilderMainImageDto";
+export { BuilderMainText, type BuilderMainTextDto } from "./BuilderMainText";
+export { type BuilderMainVideoDto } from "./BuilderMainVideoDto";
+export { type BuilderTagDto, BuilderTag, TagCollection } from "./BuilderTag";
+export { type AudioFile, type ImageFile, type VideoFile } from "./media-files";
+
+// Public Api of rule-builder
+export * from "./rulebuilder";