@valbuild/core 0.12.0 → 0.13.0

package/src/schema/object.ts

@@ -0,0 +1,67 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SchemaTypeOf, SerializedSchema } from ".";
+import { SelectorSource } from "../selector";
+import { SourcePath } from "../val";
+
+export type SerializedObjectSchema = {
+  type: "object";
+  items: Record<string, SerializedSchema>;
+  opt: boolean;
+};
+
+type ObjectSchemaProps = { [key: string]: Schema<SelectorSource> };
+type ObjectSchemaSrcOf<Props extends ObjectSchemaProps> = {
+  [key in keyof Props]: SchemaTypeOf<Props[key]>;
+};
+
+export class ObjectSchema<Props extends ObjectSchemaProps> extends Schema<
+  ObjectSchemaSrcOf<Props>
+> {
+  constructor(readonly items: Props, readonly opt: boolean = false) {
+    super();
+  }
+
+  validate(
+    src: ObjectSchemaSrcOf<Props>
+  ): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  match(src: ObjectSchemaSrcOf<Props>): boolean {
+    if (this.opt && (src === null || src === undefined)) {
+      return true;
+    }
+    if (!src) {
+      return false;
+    }
+
+    // TODO: checks all props
+
+    return typeof src === "object" && !Array.isArray(src);
+  }
+
+  optional(): Schema<ObjectSchemaSrcOf<Props> | null> {
+    return new ObjectSchema(this.items, true);
+  }
+
+  serialize(): SerializedSchema {
+    return {
+      type: "object",
+      items: Object.fromEntries(
+        Object.entries(this.items).map(([key, schema]) => [
+          key,
+          schema.serialize(),
+        ])
+      ),
+      opt: this.opt,
+    };
+  }
+}
+
+export const object = <Props extends ObjectSchemaProps>(
+  schema: Props
+): Schema<{
+  [key in keyof Props]: SchemaTypeOf<Props[key]>;
+}> => {
+  return new ObjectSchema(schema);
+};

package/src/schema/oneOf.ts

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema } from ".";
+import { ValModuleBrand } from "../module";
+import { GenericSelector } from "../selector";
+import { Source, SourceArray } from "../source";
+import { getValPath, SourcePath } from "../val";
+
+export type SerializedOneOfSchema = {
+  type: "oneOf";
+  selector: SourcePath;
+  opt: boolean;
+};
+
+type OneOfSelector<Sel extends GenericSelector<SourceArray>> =
+  Sel extends GenericSelector<infer S>
+    ? S extends (infer IS)[]
+      ? IS extends Source
+        ? GenericSelector<IS>
+        : never
+      : never
+    : never;
+
+export class OneOfSchema<
+  Sel extends GenericSelector<SourceArray>
+> extends Schema<OneOfSelector<Sel>> {
+  constructor(readonly selector: Sel, readonly opt: boolean = false) {
+    super();
+  }
+  validate(src: OneOfSelector<Sel>): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+  match(src: OneOfSelector<Sel>): boolean {
+    throw new Error("Method not implemented.");
+  }
+  optional(): Schema<OneOfSelector<Sel> | null> {
+    return new OneOfSchema(this.selector, true);
+  }
+
+  serialize(): SerializedSchema {
+    const path = getValPath(this.selector);
+    if (!path) {
+      throw new Error(
+        "Cannot serialize oneOf schema with empty selector. Make sure a Val module is used."
+      );
+    }
+    return {
+      type: "oneOf",
+      selector: path,
+      opt: this.opt,
+    };
+  }
+}
+
+export const oneOf = <
+  Src extends GenericSelector<SourceArray> & ValModuleBrand // ValModuleBrand enforces call site to pass in a val module - selectors are not allowed. The reason is that this should make it easier to patch. We might be able to relax this constraint in the future
+>(
+  valModule: Src
+): Schema<OneOfSelector<Src>> => {
+  return new OneOfSchema(valModule);
+};

package/src/schema/richtext.ts

@@ -0,0 +1,417 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema } from ".";
+import { content } from "../module";
+import { VAL_EXTENSION } from "../source";
+import { SourcePath } from "../val";
+
+export type SerializedRichTextSchema = {
+  type: "richtext";
+  opt: boolean;
+};
+
+type Node = {
+  version: 1;
+};
+
+type NodeType = Node & {
+  format: FormatType;
+  direction: DirectionType;
+  indent: number;
+};
+
+type FormatType =
+  | "left"
+  | "start"
+  | "center"
+  | "right"
+  | "end"
+  | "justify"
+  | "";
+type DirectionType = "ltr" | "rtl" | null;
+
+export type TextNode = Node & {
+  format: FormatType | number;
+  detail: number;
+  mode: "normal" | "code" | "quote";
+  style: string;
+  text: string;
+  type: "text";
+  direction?: DirectionType;
+  indent?: number;
+};
+
+export type ImageNode = Node & {
+  altText: string;
+  height: number;
+  width: number;
+  maxWidth: number;
+  src: string;
+  type: "image";
+};
+
+export type ParagraphNode<VN = TextNode> = NodeType & {
+  children: (TextNode | VN)[];
+  type: "paragraph";
+};
+
+export type HeadingNode<HT extends HeadingTags = HeadingTags> = NodeType & {
+  children: TextNode[];
+  type: "heading";
+  tag: HT;
+};
+
+export type ListItemNode<VN = TextNode> = NodeType & {
+  children: (TextNode | VN)[];
+  type: "listitem";
+  value: number;
+  checked?: boolean;
+};
+
+export type ListNode<VN = TextNode> = NodeType & {
+  children: ListItemNode<VN>[];
+  type: "list";
+  tag: "ol" | "ul";
+  listType: "number" | "bullet" | "check";
+  start?: number;
+};
+
+type HeadingTags = "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+export type RootNode<HT extends HeadingTags, VN> = Node & {
+  children: (HeadingNode<HT> | ParagraphNode<VN> | ListNode<VN>)[];
+  type: "root";
+  format: FormatType;
+  direction: DirectionType;
+  indent: number;
+};
+
+type ValNode = ImageNode;
+
+export type RichText<
+  HT extends HeadingTags = HeadingTags,
+  VN extends TextNode | ValNode = TextNode
+> = RootNode<HT, VN>;
+
+export class RichTextSchema<Src extends RichText | null> extends Schema<Src> {
+  validate(src: Src): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+  match(src: Src): boolean {
+    // TODO:
+    return true;
+  }
+
+  optional(): Schema<RichText<HeadingTags, TextNode> | null> {
+    return new RichTextSchema(true);
+  }
+  serialize(): SerializedSchema {
+    return {
+      type: "richtext",
+      opt: this.opt,
+    };
+  }
+  constructor(readonly opt: boolean = false) {
+    super();
+  }
+}
+
+export const richtext = (): Schema<RichText> => {
+  return new RichTextSchema();
+};
+
+{
+  const a = content("/test/richtext1", richtext(), {
+    children: [
+      {
+        children: [
+          {
+            detail: 0,
+            format: 0,
+            mode: "normal",
+            style: "",
+            text: "Heading 1",
+            type: "text",
+            version: 1,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "heading",
+        version: 1,
+        tag: "h1",
+      },
+      {
+        children: [
+          {
+            detail: 0,
+            format: 0,
+            mode: "normal",
+            style: "",
+            text: "Heading 2",
+            type: "text",
+            version: 1,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "heading",
+        version: 1,
+        tag: "h2",
+      },
+      {
+        children: [],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [
+          {
+            detail: 0,
+            format: 0,
+            mode: "normal",
+            style: "",
+            text: "Normal",
+            type: "text",
+            version: 1,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [
+          {
+            detail: 0,
+            format: 0,
+            mode: "normal",
+            style: "font-size: 20px;",
+            text: "Normal Font size 20",
+            type: "text",
+            version: 1,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [
+          {
+            detail: 0,
+            format: 0,
+            mode: "normal",
+            style: "font-family: serif;",
+            text: "Normal font type serif",
+            type: "text",
+            version: 1,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [
+          {
+            detail: 0,
+            format: 1,
+            mode: "normal",
+            style: "font-family: serif;",
+            text: "Serif and bold",
+            type: "text",
+            version: 1,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [
+          {
+            detail: 0,
+            format: 2,
+            mode: "normal",
+            style: "",
+            text: "Arial and italic",
+            type: "text",
+            version: 1,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [],
+        direction: null,
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [
+          {
+            children: [
+              {
+                detail: 0,
+                format: 0,
+                mode: "normal",
+                style: "",
+                text: "Num list 1",
+                type: "text",
+                version: 1,
+              },
+            ],
+            direction: "ltr",
+            format: "",
+            indent: 0,
+            type: "listitem",
+            version: 1,
+            value: 1,
+          },
+          {
+            children: [
+              {
+                detail: 0,
+                format: 0,
+                mode: "normal",
+                style: "",
+                text: "Num list 2",
+                type: "text",
+                version: 1,
+              },
+              // TODO: image
+              // {
+              //   altText: "",
+              //   height: 0,
+              //   maxWidth: 0,
+              //   src: "https://picsum.photos/id/237/200/300",
+              //   type: "image",
+              //   version: 1,
+              //   width: 0,
+              // },
+            ],
+            direction: "ltr",
+            format: "",
+            indent: 0,
+            type: "listitem",
+            version: 1,
+            value: 2,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "list",
+        version: 1,
+        listType: "number",
+        start: 1,
+        tag: "ol",
+      },
+      {
+        children: [],
+        direction: null,
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [
+          {
+            children: [
+              {
+                detail: 0,
+                format: 0,
+                mode: "normal",
+                style: "",
+                text: "Bullet list 1",
+                type: "text",
+                version: 1,
+              },
+            ],
+            direction: "ltr",
+            format: "",
+            indent: 0,
+            type: "listitem",
+            version: 1,
+            value: 1,
+          },
+          {
+            children: [
+              {
+                detail: 0,
+                format: 0,
+                mode: "normal",
+                style: "",
+                text: "Bullet list 2",
+                type: "text",
+                version: 1,
+              },
+            ],
+            direction: "ltr",
+            format: "",
+            indent: 0,
+            type: "listitem",
+            version: 1,
+            value: 2,
+          },
+        ],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "list",
+        version: 1,
+        listType: "bullet",
+        start: 1,
+        tag: "ul",
+      },
+      {
+        children: [],
+        direction: null,
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [],
+        direction: "ltr",
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+      {
+        children: [],
+        direction: null,
+        format: "",
+        indent: 0,
+        type: "paragraph",
+        version: 1,
+      },
+    ],
+    direction: "ltr",
+    format: "",
+    indent: 0,
+    type: "root",
+    version: 1,
+  });
+}

package/src/schema/string.ts

@@ -0,0 +1,49 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+
+type StringOptions = {
+  maxLength?: number;
+  minLength?: number;
+};
+
+export type SerializedStringSchema = {
+  type: "string";
+  options?: StringOptions;
+  opt: boolean;
+};
+
+export class StringSchema<Src extends string | null> extends Schema<Src> {
+  constructor(readonly options?: StringOptions, readonly opt: boolean = false) {
+    super();
+  }
+
+  validate(src: Src): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  match(src: Src): boolean {
+    if (this.opt && (src === null || src === undefined)) {
+      return true;
+    }
+    return typeof src === "string";
+  }
+
+  optional(): Schema<Src | null> {
+    return new StringSchema<Src | null>(this.options, true);
+  }
+
+  serialize(): SerializedSchema {
+    return {
+      type: "string",
+      options: this.options,
+      opt: this.opt,
+    };
+  }
+}
+
+export const string = <T extends string>(
+  options?: StringOptions
+): Schema<T> => {
+  return new StringSchema(options);
+};

package/src/schema/union.ts

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema } from ".";
+import { SelectorSource } from "../selector";
+import { SourceObject } from "../source";
+import { SourcePath } from "../val";
+
+export type SerializedUnionSchema = {
+  type: "union";
+  key: string;
+  items: SerializedSchema[];
+  opt: boolean;
+};
+
+type SourceOf<
+  Key extends string,
+  T extends Schema<SourceObject & { [k in Key]: string }>[]
+> = T extends Schema<infer S>[]
+  ? S extends SelectorSource
+    ? S
+    : never
+  : never;
+
+export class UnionSchema<
+  Key extends string,
+  T extends Schema<SourceObject & { [k in Key]: string }>[]
+> extends Schema<SourceOf<Key, T>> {
+  validate(src: SourceOf<Key, T>): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+  match(src: SourceOf<Key, T>): boolean {
+    throw new Error("Method not implemented.");
+  }
+  optional(): Schema<SourceOf<Key, T> | null> {
+    throw new Error("Method not implemented.");
+  }
+  serialize(): SerializedSchema {
+    return {
+      type: "union",
+      key: this.key,
+      items: this.items.map((o) => o.serialize()),
+      opt: this.opt,
+    };
+  }
+
+  constructor(
+    readonly key: Key,
+    readonly items: T,
+    readonly opt: boolean = false
+  ) {
+    super();
+  }
+}
+
+export const union = <
+  Key extends string,
+  T extends Schema<SourceObject & { [k in Key]: string }>[]
+>(
+  key: Key,
+  ...objects: T
+): Schema<SourceOf<Key, T>> => {
+  return new UnionSchema(key, objects);
+};