@media-quest/builder 0.0.24 → 0.0.26

package/src/Builder-schema.ts

@@ -2,25 +2,28 @@ import type { BuilderPageDto, BuilderPageType } from "./Builder-page";
 import { BuilderPage } from "./Builder-page";
 import type {
   BuilderRuleDto,
-  CustomVariable,
   ExcludeByPageAction,
   ExcludeByTagAction,
   JumpToPageAction,
+  RuleCustomVariable,
 } from "./rulebuilder";
 import { BuilderRule, RuleInput } from "./rulebuilder";
-import type { QuestionVariable } from "./rulebuilder/RuleVariable";
+import type { RuleQuestionVariable } from "./rulebuilder/RuleVariable";
 import type { BuilderTagDto } from "./BuilderTag";
 import { BuilderTag, TagCollection } from "./BuilderTag";
 import { DefaultThemeCompiler } from "./theme/default-theme-compiler";
 import { ImageFile } from "./media-files";
-import { DUtil, SchemaID } from "@media-quest/engine";
+import { DUtil } from "@media-quest/engine";
 import { PagePrefix } from "./primitives/page-prefix";
 import { SchemaPrefix, SchemaPrefixValue } from "./primitives/schema-prefix";
-import { CodeBook } from "./codebook";
-import { PredefinedVariable } from "./variable/mq-variable";
+import { CodeBook } from "./code-book/codebook";
+import { CodebookPredefinedVariable } from "./code-book/codebook-variable";
 import { SchemaConfig } from "./schema-config";
 import { CompilerOption, CompilerOutput } from "./builder-compiler";
-import { SumScoreVariable } from "./variable/sum-score";
+
+import { SumScoreVariableDto } from "./sum-score/sum-score-variable";
+import { SchemaID } from "./primitives/ID";
+import { SumScoreMembershipDto } from "./sum-score/sum-score-membership";
 
 const U = DUtil;
 
@@ -33,14 +36,15 @@ export interface BuilderSchemaDto {
   readonly pages: BuilderPageDto[];
   readonly baseHeight: number;
   readonly baseWidth: number;
-  readonly predefinedVariables?: Array<PredefinedVariable>;
-  readonly sumScoreVariables?: Array<SumScoreVariable>;
+  readonly predefinedVariables?: Array<CodebookPredefinedVariable>;
+  readonly sumScoreVariables?: ReadonlyArray<SumScoreVariableDto>;
+  readonly sumScoreMemberShips?: ReadonlyArray<SumScoreMembershipDto>;
   readonly rules: ReadonlyArray<BuilderRuleDto>;
   readonly tags: ReadonlyArray<BuilderTagDto>;
 }
 
 class SumScoreVariableCollection {
-  private _all: Array<SumScoreVariable> = [];
+  private _all: Array<SumScoreVariableDto> = [];
 }
 
 export class BuilderSchema {
@@ -50,13 +54,13 @@ export class BuilderSchema {
   backgroundColor = "#000000";
   pages: BuilderPage[] = [];
   mainImage: ImageFile | false = false;
-  predefinedVariables: PredefinedVariable[] = [];
+  predefinedVariables: CodebookPredefinedVariable[] = [];
   private _rules: BuilderRule[] = [];
-  private _sumVariables: SumScoreVariable[] = [];
+  private _sumVariables: SumScoreVariableDto[] = [];
   get rules(): ReadonlyArray<BuilderRule> {
     return [...this._rules];
   }
-  get sumScoreVariables(): ReadonlyArray<SumScoreVariable> {
+  get sumScoreVariables(): ReadonlyArray<SumScoreVariableDto> {
     return [...this._sumVariables];
   }
 
@@ -77,6 +81,7 @@ export class BuilderSchema {
     const schemaPrefix = SchemaPrefix.castOrCreateRandom(dto.prefix);
     const schema = new BuilderSchema(dto.id, dto.name, schemaPrefix);
     const pages = dto.pages.map(BuilderPage.fromJson);
+
     schema._tagCollection.init(dto.tags);
     schema.backgroundColor = dto.backgroundColor;
     schema.baseHeight = dto.baseHeight;
@@ -87,6 +92,8 @@ export class BuilderSchema {
     schema.mainImage = dto.mainImage ?? false;
     const rulesDto = dto.rules ?? [];
     const ruleInput = schema.getRuleInput();
+
+    schema._sumVariables = Array.isArray(dto.sumScoreVariables) ? [...dto.sumScoreVariables] : [];
     schema._rules = rulesDto.map((r) => BuilderRule.fromDto(r, ruleInput));
     return schema;
   }
@@ -106,6 +113,7 @@ export class BuilderSchema {
       rules,
       tags,
       predefinedVariables: this.predefinedVariables,
+      sumScoreVariables: [...this.sumScoreVariables],
       mainImage: this.mainImage,
       prefix: this.prefix.value,
     };
@@ -130,9 +138,11 @@ export class BuilderSchema {
     return newPage;
   }
 
-  addSumScoreVariable(variable: SumScoreVariable) {
+  addSumScoreVariable(variable: SumScoreVariableDto) {
     // TODO VALIDATE.
     this._sumVariables.push({ ...variable });
+
+    return variable;
   }
 
   insertPage(page: BuilderPage, atIndex: number): boolean {
@@ -204,8 +214,8 @@ export class BuilderSchema {
   }
 
   getRuleInput(): RuleInput {
-    const qVars: QuestionVariable[] = [];
-    const cVars: CustomVariable[] = [];
+    const qVars: RuleQuestionVariable[] = [];
+    const cVars: RuleCustomVariable[] = [];
     const pageIdActions: ExcludeByPageAction[] = [];
     const tagActions: ExcludeByTagAction[] = this.tags.map((t) => {
       const tag = t.tagText;

package/src/Builder-text.spec.ts

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

package/src/Builder-text.ts

@@ -1,17 +1,18 @@
-import { BuilderObjectId, BuilderObject } from './BuilderObject';
+import { BuilderObject } from "./BuilderObject";
+import { TextID } from "./primitives/ID";
 
 export interface BuilderTextDto {
-  readonly id: BuilderObjectId.TextID;
+  readonly id: TextID;
   text: string;
   name: string;
   translationRequired: boolean;
 }
 
-export class BuilderText extends BuilderObject<'builder-text', BuilderTextDto> {
-  readonly objectType = 'builder-text';
-  id: BuilderObjectId.TextID;
-  text = '';
-  name = '';
+export class BuilderText extends BuilderObject<"builder-text", BuilderTextDto> {
+  readonly objectType = "builder-text";
+  id: TextID;
+  text = "";
+  name = "";
   translateRequired = false;
   // audio: {id: B}
   private constructor(dto: BuilderTextDto) {
@@ -23,12 +24,12 @@ export class BuilderText extends BuilderObject<'builder-text', BuilderTextDto> {
   }
 
   public static create(name: string) {
-    const id = BuilderObjectId.textId();
+    const id = TextID.create();
     const dto: BuilderTextDto = {
       id,
       name,
-      text: '',
-      translationRequired: false
+      text: "",
+      translationRequired: false,
     };
     const instance = new BuilderText(dto);
     return instance;
@@ -39,9 +40,8 @@ export class BuilderText extends BuilderObject<'builder-text', BuilderTextDto> {
   }
 
   clone(): BuilderTextDto {
-    const newId = BuilderObjectId.textId();
     const dto = this.toJson();
-    const withNewId: BuilderTextDto = { ...dto, id: newId };
+    const withNewId: BuilderTextDto = { ...dto, id: TextID.create() };
     return withNewId;
   }
 
@@ -50,7 +50,7 @@ export class BuilderText extends BuilderObject<'builder-text', BuilderTextDto> {
       id: this.id,
       name: this.name,
       text: this.text,
-      translationRequired: this.translateRequired
+      translationRequired: this.translateRequired,
     };
     return dto;
   }

package/src/BuilderObject.ts

@@ -1,6 +1,3 @@
-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
@@ -14,40 +11,12 @@ type BuilderObjectType =
   | "builder-text"
   | "builder-rule"
   | "builder-tag"
+  | "builder-sum-score-variable"
+  | "builder-sum-score-membership"
   | "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 TextID = string & { __TEXT__ID__: true };
-  export type MainTextID = string & { __MAIN__TEXT__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;
-  };
-
-  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;

package/src/BuilderTag.ts

@@ -1,25 +1,26 @@
-import { BuilderObjectId, BuilderObject } from './BuilderObject';
+import { BuilderObject } from "./BuilderObject";
+import { TagID } from "./primitives/ID";
 
 export interface BuilderTagDto {
-  readonly id: BuilderObjectId.TagId;
+  readonly id: 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 = '';
+export class BuilderTag extends BuilderObject<"builder-tag", BuilderTagDto> {
+  readonly objectType: "builder-tag" = "builder-tag";
+  readonly id: 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();
+  public static readonly create = (tag: string, description: string = "") => {
+    const id = TagID.create();
     const dto: BuilderTagDto = {
       id,
       tag,
-      description
+      description,
     };
     return new BuilderTag(dto);
   };
@@ -27,12 +28,12 @@ export class BuilderTag extends BuilderObject<'builder-tag', BuilderTagDto> {
     return new BuilderTag(dto);
   };
   protected constructor(dto: BuilderTagDto) {
-    const id = dto.id ?? BuilderObjectId.createTagId();
+    const id = TagID.validateOrCreate(dto.id);
     const withId = { ...dto, id };
     super(withId);
     this.id = id;
-    this.tagText = dto.tag ?? '';
-    this.tagDescription = dto.description ?? '';
+    this.tagText = dto.tag ?? "";
+    this.tagDescription = dto.description ?? "";
   }
   clone(): BuilderTagDto {
     return this.toJson();
@@ -54,17 +55,15 @@ export class TagCollection implements Iterable<BuilderTag> {
     return list[Symbol.iterator]();
   }
   private constructor(initialTags: ReadonlyArray<BuilderTag>) {
-    initialTags.forEach(tag => {
+    initialTags.forEach((tag) => {
       this._tags.add(tag);
     });
   }
 
   init(tags: ReadonlyArray<BuilderTagDto>) {
-    const dtoList: ReadonlyArray<BuilderTagDto> = Array.isArray(tags)
-      ? tags
-      : [];
+    const dtoList: ReadonlyArray<BuilderTagDto> = Array.isArray(tags) ? tags : [];
     const all = dtoList.map(BuilderTag.fromDto);
-    all.forEach(tag => {
+    all.forEach((tag) => {
       this._tags.add(tag);
     });
   }
@@ -83,14 +82,14 @@ export class TagCollection implements Iterable<BuilderTag> {
 
   toJson(): ReadonlyArray<BuilderTagDto> {
     const list = [...this._tags];
-    const dtoList = list.map(t => t.toJson());
+    const dtoList = list.map((t) => t.toJson());
     return dtoList;
   }
 
   deleteAll(tags: Iterable<BuilderTag>) {
     const l = tags[Symbol.iterator]();
     const asList = [...tags];
-    asList.forEach(t => {
+    asList.forEach((t) => {
       this.delete(t);
     });
   }

package/src/builder-compiler.ts

@@ -1,5 +1,5 @@
 import { SchemaDto } from "@media-quest/engine";
-import { Codebook } from "./codebook";
+import { Codebook } from "./code-book/codebook";
 import { SchemaConfig } from "./schema-config";
 
 export interface CompilerOutput {

package/src/code-book/codebook-variable.ts

@@ -0,0 +1,29 @@
+import { PageID } from "../primitives/ID";
+
+/**
+ * Interface representing a code book question sum-score.
+ *
+ * @interface
+ */
+export interface CodeBookQuestionVariable {
+  readonly kind: "codebook-question-variable";
+  readonly label: string;
+  readonly varId: string;
+  readonly pageId: PageID;
+  readonly pagePrefix: string;
+  readonly modulePrefix: string;
+  /**
+   * Show the position of the question on page (a, b, c, d, ...)
+   */
+  readonly questionPrefix: string;
+  readonly pagePosition: number;
+  readonly options: ReadonlyArray<{ label: string; value: number }>;
+}
+
+export interface CodebookPredefinedVariable {
+  readonly kind: "codebook-predefined-variable";
+  readonly modulePrefix: string;
+  readonly moduleID: string;
+  defaultValue: number;
+  options: Array<{ label: string; value: number }>;
+}

package/src/{codebook.ts → code-book/codebook.ts}

@@ -1,37 +1,37 @@
-import { BuilderPageDto } from "./Builder-page";
-import { BuilderSchemaDto } from "./Builder-schema";
-import { PageVariable, PredefinedVariable } from "./variable/mq-variable";
+import { BuilderPageDto } from "../Builder-page";
+import { BuilderSchemaDto } from "../Builder-schema";
+import { CodeBookQuestionVariable, CodebookPredefinedVariable } from "./codebook-variable";
 
 export interface Codebook {
-  readonly predefinedVariables: ReadonlyArray<PredefinedVariable>;
-  readonly pageVariables: ReadonlyArray<PageVariable>;
+  readonly predefinedVariables: ReadonlyArray<CodebookPredefinedVariable>;
+  readonly pageVariables: ReadonlyArray<CodeBookQuestionVariable>;
 }
 
 const fromPage = (
   page: BuilderPageDto,
   pagePosition: number,
   modulePrefix: string,
-): PageVariable[] => {
-  const variables: PageVariable[] = [];
+): CodeBookQuestionVariable[] => {
+  const variables: CodeBookQuestionVariable[] = [];
 
   if (page._type !== "question") {
     // TODO Implement form field variables
     return [];
   }
 
-  const options: PageVariable["options"] = page.defaultQuestion.options.map((o) => {
+  const options: CodeBookQuestionVariable["options"] = page.defaultQuestion.options.map((o) => {
     return { value: o.value, label: o.label };
   });
 
-  const variable: PageVariable = {
-    kind: "numeric-variable",
+  const variable: CodeBookQuestionVariable = {
+    kind: "codebook-question-variable",
     label: page.mainText.text,
+    pageId: page.id,
+    pagePrefix: page.prefix,
     options,
     modulePrefix,
-    origin: "question",
-    pageId: page.id,
     pagePosition,
-    pagePrefix: page.prefix,
+    questionPrefix: "",
     varId: modulePrefix + "_" + page.prefix,
   };
 
@@ -48,8 +48,8 @@ const fromPage = (
 const getPageVariablesFromPages = (
   pages: BuilderPageDto[],
   modulePrefix: string,
-): PageVariable[] => {
-  const variables: PageVariable[] = [];
+): CodeBookQuestionVariable[] => {
+  const variables: CodeBookQuestionVariable[] = [];
   pages.forEach((page, index) => {
     const pageVariables = fromPage(page, index, modulePrefix);
     variables.push(...pageVariables);
@@ -61,7 +61,7 @@ const fromSchema = (schema: BuilderSchemaDto): Codebook => {
   const modulePrefix = schema.prefix;
   const pageVariables = getPageVariablesFromPages(schema.pages, modulePrefix);
   const vs = schema.predefinedVariables;
-  const predefinedVariables: PredefinedVariable[] = vs ? [...vs] : [];
+  const predefinedVariables: CodebookPredefinedVariable[] = vs ? [...vs] : [];
   return { pageVariables, predefinedVariables };
 };
 

package/src/primitives/ID.spec.ts

@@ -0,0 +1,39 @@
+import { PageID, SchemaID } from "./ID";
+
+describe("ID Functions work", () => {
+  //Generate test for schema prefix
+  test("SCHEMA_ID isFunction works", () => {
+    const id = SchemaID.create();
+    expect(SchemaID.is(id)).toBe(true);
+    expect(SchemaID.is("")).toBe(false);
+    expect(SchemaID.is("a")).toBe(false);
+    expect(SchemaID.is("a".repeat(10))).toBe(true);
+    expect(SchemaID.is("a".repeat(9))).toBe(false);
+  });
+  test("SCHEMA_ID ensure works", () => {
+    const id = SchemaID.create();
+    expect(SchemaID.validateOrCreate(id)).toBe(id);
+    expect(SchemaID.validateOrCreate("")).not.toBe("");
+    expect(SchemaID.validateOrCreate("")).not.toBe("a");
+    expect(SchemaID.validateOrCreate("a".repeat(10))).toBe("a".repeat(10));
+    expect(SchemaID.validateOrCreate("a".repeat(9))).not.toBe("a".repeat(9));
+    expect(SchemaID.validateOrCreate("ABcdefghigKLML")).toBe("ABcdefghigKLML");
+  });
+  test("PageID isFunction works", () => {
+    const id = PageID.create();
+    expect(PageID.is(id)).toBe(true);
+    expect(PageID.is("")).toBe(false);
+    expect(PageID.is("a")).toBe(false);
+    expect(PageID.is("a".repeat(10))).toBe(true);
+    expect(PageID.is("a".repeat(9))).toBe(false);
+  });
+  test("PageID ensure works", () => {
+    const id = PageID.create();
+    expect(PageID.validateOrCreate(id)).toBe(id);
+    expect(PageID.validateOrCreate("")).not.toBe("");
+    expect(PageID.validateOrCreate("")).not.toBe("a");
+    expect(PageID.validateOrCreate("a".repeat(10))).toBe("a".repeat(10));
+    expect(PageID.validateOrCreate("a".repeat(9))).not.toBe("a".repeat(9));
+    expect(PageID.validateOrCreate("ABcdefghigKLML")).toBe("ABcdefghigKLML");
+  });
+});

package/src/primitives/ID.ts

@@ -0,0 +1,138 @@
+// The default length of an ID
+const ID_LENGTH = 32;
+
+// The minimum length of an ID
+const MIN_LENGTH = 10;
+
+export type ID<B extends string> = string & { __ID__: B };
+
+const isID = <const B extends string>(idName: B, id?: string): id is ID<B> => {
+  if (typeof id !== "string") return false;
+  return id.length >= MIN_LENGTH;
+};
+
+const createIDByName = <const B extends string>(idName: B): ID<B> => {
+  const letters = "abcdefghijklmnopqrstuvyz";
+  const all = letters + letters.toUpperCase();
+  let result = "";
+
+  for (let i = 0; i < ID_LENGTH; i++) {
+    const char = all.charAt(Math.floor(Math.random() * all.length));
+    result += char;
+  }
+
+  return result as ID<B>;
+};
+const createDummyID = <const B extends string>(idName: B, letter: string): ID<B> => {
+  return letter.repeat(ID_LENGTH) as ID<B>;
+};
+interface Id<T extends string> {
+  name: T;
+  is: (id: string) => id is ID<T>;
+  validateOrCreate: (id: string) => ID<T>;
+  validateOrThrow: (id: string) => ID<T>;
+  create: () => ID<T>;
+  dummy: {
+    a: ID<T>;
+    b: ID<T>;
+    c: ID<T>;
+    d: ID<T>;
+    e: ID<T>;
+    f: ID<T>;
+    g: ID<T>;
+    h: ID<T>;
+    i: ID<T>;
+    j: ID<T>;
+  };
+}
+
+/**
+ * Creates a object with helper functions for a specific ID type
+ * @param idName
+ */
+export const createTypedIdSingleton = <const B extends string>(idName: B): Id<B> => {
+  /**
+   * Creates a new ID of the correct type
+   */
+  const create = (): ID<B> => createIDByName(idName);
+
+  /**
+   * Checks if the id is of the correct type
+   * @param id
+   */
+  const is = (id: string): id is ID<B> => isID(idName, id);
+
+  /**
+   * Checks if the id is of the correct type, if not it throws an error
+   * @param id
+   */
+  const validateOrThrow = (id: string): ID<B> => {
+    if (!is(id)) {
+      throw new Error(`Invalid id: ${id}`);
+    }
+    return id;
+  };
+
+  /**
+   * The lowercase name of the id (SCHEMA, PAGE, etc)
+   */
+  const name: B = idName;
+
+  /**
+   * Ensures that the id is of the correct type, if not it creates a new one
+   * @param id
+   */
+  const validateOrCreate = (id: string): ID<B> => {
+    return is(id) ? id : create();
+  };
+
+  const a = createDummyID(idName, "a");
+  const b = createDummyID(idName, "b");
+  const c = createDummyID(idName, "c");
+  const d = createDummyID(idName, "d");
+  const e = createDummyID(idName, "e");
+  const f = createDummyID(idName, "f");
+  const g = createDummyID(idName, "g");
+  const h = createDummyID(idName, "h");
+  const i = createDummyID(idName, "i");
+  const j = createDummyID(idName, "j");
+  const list = [a, b, c, d, e, f, g, h, i, j];
+
+  const dummy = {
+    a,
+    b,
+    c,
+    d,
+    e,
+    f,
+    g,
+    h,
+    i,
+    j,
+    list,
+  };
+
+  return Object.freeze({ create, is, validateOrCreate, validateOrThrow, name, dummy });
+};
+
+export type SchemaID = ID<"SCHEMA">;
+export const SchemaID = createTypedIdSingleton("SCHEMA");
+
+export type PageID = ID<"PAGE">;
+export const PageID = createTypedIdSingleton("PAGE");
+
+export type TagID = ID<"TAG">;
+export const TagID = createTypedIdSingleton("TAG");
+export type OptionID = ID<"OPTION">;
+export const OptionID = createTypedIdSingleton("OPTION");
+
+export type TextID = ID<"TEXT">;
+export const TextID = createTypedIdSingleton("TEXT");
+export type QuestionID = ID<"QUESTION">;
+export const QuestionID = createTypedIdSingleton("QUESTION");
+
+export type SumScoreVariableID = ID<"SUM_SCORE_VARIABLE">;
+export const SumScoreVariableID = createTypedIdSingleton("SUM_SCORE_VARIABLE");
+
+export type SumScoreMemberShipID = ID<"SUM_SCORE_MEMBERSHIP">;
+export const SumScoreMemberShipID = createTypedIdSingleton("SUM_SCORE_MEMBERSHIP");

package/src/primitives/page-prefix.ts

@@ -31,15 +31,16 @@ export class PagePrefix {
     return value;
   };
   public static castOrCreateRandom = (value: string): PagePrefix => {
-    const v = PagePrefix.isValid(value) ? value : createRandomPrefix<PagePrefixValue>(PagePrefix.randomLen);
+    const v = PagePrefix.isValid(value)
+      ? value
+      : createRandomPrefix<PagePrefixValue>(PagePrefix.randomLen);
     return new PagePrefix(v);
   };
 
   public static isValid = (prefix: string | 999): prefix is PagePrefixValue => {
     if (typeof prefix !== "string") return false;
     if (prefix.length < SchemaPrefix.MIN_LENGTH) return false;
-    if (prefix.length > SchemaPrefix.MAX_LENGTH) return false;
-    return true;
+    return prefix.length <= SchemaPrefix.MAX_LENGTH;
   };
 
   get value(): PagePrefixValue {

package/src/primitives/varID.ts

@@ -3,6 +3,7 @@ import { PagePrefixValue } from "./page-prefix";
 import { SchemaPrefixValue } from "./schema-prefix";
 
 export type VarID = `${SchemaPrefixValue}_${PagePrefixValue}`;
+
 export const VarID = {
   create: (schemaPrefix: SchemaPrefixValue, pagePrefix: PagePrefixValue): VarID => {
     const varId = schemaPrefix + "_" + pagePrefix;