@valbuild/core 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valbuild/core",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "private": false,
   "description": "Val - supercharged hard-coded content",
   "scripts": {
@@ -39,8 +39,17 @@
     ],
     "exports": true
   },
-  "devDependencies": {
+  "devDependencies": {},
+  "dependencies": {
     "ts-toolbelt": "^9.6.0"
   },
-  "dependencies": {}
+  "files": [
+    "dist",
+    "fp/dist",
+    "fp/package.json",
+    "expr/dist",
+    "expr/package.json",
+    "patch/dist",
+    "patch/package.json"
+  ]
 }

package/ROADMAP.md

@@ -1,106 +0,0 @@
-# Planned features
-
-## i18n
-
-Example:
-
-```tsx
-// file: ./blogs.val.ts
-
-export const schema = s.array(
-  s.i18n(s.object({ title: s.string(), text: s.richtext() }))
-);
-
-export default val.content("/blogs", schema, [
-  {
-    en_US: {
-      title: "Title 1",
-      text: val.richtext("Richtext 1"),
-    },
-    nb_NO: {
-      title: "Tittel 1",
-      text: val.richtext("Riktekst?"),
-    },
-  },
-]);
-
-// file: ./components/ServerComponent.ts
-
-import blogsVal from "./blogs.val";
-
-export async function ServerComponent({ index }: { index: number }) {
-  const blogs = await fetchVal(blogVal, getLocale());
-
-  // NOTE: automatically resolves the locale
-  const title = blogs[index].title; // is a string
-  return <div>{title}</div>;
-}
-```
-
-Missing infrastructure: none in particular.
-
-## remote
-
-Remote makes it possible to move content to cloud storage (and back again). It uses immutable references, so local work, branches still works.
-
-Example:
-
-```tsx
-// file: ./blogs.val.ts
-
-export const schema = s
-  .array(s.object({ title: s.string(), text: s.richtext() }))
-  .remote();
-
-export default val.content(
-  "/blogs",
-  schema,
-  val.remote("4ba7c33b32a60be06b1b26dff8cc5d8d967660ab") // a change in content, will result in a new reference
-);
-
-// file: ./components/ServerComponent.ts
-
-import blogsVal from "./blogs.val";
-
-export async function ServerComponent({ index }: { index: number }) {
-  const blog = await fetchVal(
-    blogVal[index] // only fetch the blog at index
-  );
-  const title = blog.title;
-  return <div>{title}</div>;
-}
-```
-
-Missing infrastructure: cloud support, patch support, selectors proxy needs to be able to switch between remote and source (see selectors/future), editor plugin to improve DX (refactors, ...)?
-
-## oneOf
-
-oneOf makes it possible to reference an item in an array of in another val module.
-
-Example:
-
-```ts
-// file: ./employees.val.ts
-
-export schema = s.array(s.object({ name: s.string() }));
-
-export default val.content('/employees', schema, [{
-  name: 'John Smith',
-}]);
-
-// file: ./contacts.val.ts
-
-import employeesVal from './employees.val';
-
-export schema = s.object({
-  hr: s.oneOf(employeesVal),
-});
-
-export default val.content('/contacts', schema, {
-  hr: employeesVal[0]
-});
-
-
-```
-
-Missing infrastructure: need a change in how patches are applied for source files to handle selectors inside data.

package/jest.config.js

@@ -1,4 +0,0 @@
-/** @type {import("jest").Config} */
-module.exports = {
-  preset: "../../jest.preset",
-};

package/src/Json.ts

@@ -1,4 +0,0 @@
-export type Json = JsonPrimitive | JsonObject | JsonArray;
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonArray = readonly Json[];
-export type JsonObject = { readonly [key in string]: Json };

package/src/ValApi.ts

@@ -1,81 +0,0 @@
-import { ApiPatchResponse, ApiTreeResponse } from ".";
-import { result } from "./fp";
-import { PatchJSON } from "./patch";
-import { ModuleId } from "./val";
-
-type FetchError = { message: string; statusCode?: number };
-
-// TODO: move this to internal, only reason this is here is that react, ui and server all depend on it
-export class ValApi {
-  constructor(public host: string) {}
-
-  getDisableUrl() {
-    return `${this.host}/disable`;
-  }
-  getEditUrl() {
-    return `${this.host}/static/edit`;
-  }
-
-  postPatches(
-    moduleId: ModuleId,
-    patches: PatchJSON,
-    headers?: Record<string, string> | undefined
-  ) {
-    return fetch(`${this.host}/patches/~`, {
-      headers: headers || {
-        "Content-Type": "application/json",
-      },
-      method: "POST",
-      body: JSON.stringify({ [moduleId]: patches }),
-    }).then((res) => parse<ApiPatchResponse>(res));
-  }
-
-  getSession() {
-    return fetch(`${this.host}/session`).then((res) =>
-      parse<{
-        mode: "proxy" | "local";
-        member_role: "owner" | "developer" | "editor";
-      }>(res)
-    );
-  }
-
-  getModules({
-    patch = false,
-    includeSchema = false,
-    includeSource = false,
-    treePath = "/",
-    headers,
-  }: {
-    patch?: boolean;
-    includeSchema?: boolean;
-    includeSource?: boolean;
-    treePath?: string;
-    headers?: Record<string, string> | undefined;
-  }) {
-    const params = new URLSearchParams();
-    params.set("patch", patch.toString());
-    params.set("schema", includeSchema.toString());
-    params.set("source", includeSource.toString());
-    return fetch(`${this.host}/tree/~${treePath}?${params.toString()}`, {
-      headers,
-    }).then((res) => parse<ApiTreeResponse>(res));
-  }
-}
-
-// TODO: validate
-async function parse<T>(res: Response): Promise<result.Result<T, FetchError>> {
-  try {
-    if (res.ok) {
-      return result.ok(await res.json());
-    } else {
-      return result.err({
-        statusCode: res.status,
-        message: await res.text(),
-      });
-    }
-  } catch (err) {
-    return result.err({
-      message: err instanceof Error ? err.message : "Unknown error",
-    });
-  }
-}

package/src/expr/README.md

@@ -1,193 +0,0 @@
-# Visp
-
-Visp (as in Val Lisp or whisk in Norwegian) is a Lisp used to serialize Val `Selector`s.
-
-It is an INTERNAL language - it is NOT designed to be used by end-users.
-This document is architectural overview for this INTERNAL language - it is documentation for developers working on Val.
-
-Visp exists since Val clients must be able to execute remote `Selector`s.
-See the docs for remote `Schema`s for more about this.
-
-The design goals are as follows:
-
-- evaluate to `Val` objects
-- easy to parse and serialize
-- easy to evaluate in JavaScript
-- readable by Vals developers (for internal debugging)
-- stable language semantics to avoid breaking changes as Visp is part of the (internal) API versioning
-- does not support more functionality than what is required to serialize `Selector`s
-
-The non-goals are:
-
-- Visp does not need to be convenient to write - `Selector`s are used to write it
-- Visp does not need to be easily understandable by end-users of Val
-
-## Syntax
-
-Visp is a Lisp which only can evaluate one expression at a time.
-
-Read more about how it works in sections that follows.
-
-### Property access
-
-```visp
-('title' foo)
-```
-
-corresponds to:
-
-```js
-foo["title"];
-```
-
-There are no numbers in Visp, so arrays are indexed in the same way:
-
-```visp
-('0' foo)
-```
-
-corresponds to:
-
-```js
-foo["0"]; // same as foo[0]
-```
-
-### Function calls
-
-Function calls are similar to property access, but with arguments separated by whitespace:
-
-```visp
-(fnname foo arg1 arg2)
-```
-
-corresponds to:
-
-```js
-foo["fnname"](arg1, arg2); // same as foo.fname(arg1, arg2)
-```
-
-#### Higher order functions
-
-Higher order functions must be prefixed with the `!` character.
-Arguments can be accessed using the `@` character. The `@` must be suffixed with indexes, e.g. `@[0,0]`, the first one corresponding to the stack depth and the second corresponds to index of the argument list.
-
-```visp
-!(map foo @[0,0])
-```
-
-corresponds to:
-
-```js
-foo.map((v) => v);
-```
-
-Here we access the second argument of a function:
-
-```visp
-!(map foo @[0,1])
-```
-
-corresponds to:
-
-```js
-foo.map((_, i) => i);
-```
-
-This example shows how higher functions and arguments can be nested:
-
-```visp
-!(map foo !(map @[0,0] (slice @[1,0] @[0,1])))
-```
-
-corresponds to:
-
-```js
-foo.map((v, i) => v.map((j) => j.slice(i)));
-```
-
-### Literals
-
-Visp only supports string literals.
-
-Example:
-
-```visp
-'foo'
-```
-
-corresponds to:
-
-```js
-"foo";
-```
-
-### String templates
-
-Val has support for string templates similar to JavaScript.
-They are denoted using single quotes `'` (as string literal), but can inject expressions using `${}`.
-
-Example:
-
-```visp
-'foo ${('title' obj)} bar'
-```
-
-corresponds to:
-
-```js
-`foo ${obj["title"]} bar`;
-```
-
-### Special symbols
-
-### `()`
-
-The `()` symbol evaluates to `undefined`.
-
-#### `@`
-
-This symbol can be used to access arguments in [higher order functions](#higher-order-functions).
-
-### `!`
-
-This is a prefix to a [higher order function](#higher-order-functions).
-
-### val
-
-The `val` symbol is used to access data from a Val module.
-
-Example:
-
-```visp
-(val '/foo/bar`)
-```
-
-Returns the `Source` of a Val module of id `/foo/bar`.
-
-### json
-
-The `json` symbol is used to parse json strings.
-
-Example:
-
-```visp
-(json '{"foo": "bar"}')
-```
-
-To create numbers, lists etc, the `json` symbol can be used.
-
-It is also possible to use `json` with string templates:
-
-```visp
-(json '{ "foo": ${('title' obj)} }')
-```
-
-corresponds to:
-
-```js
-JSON.parse(`{ "foo": ${obj["title"]} }`);
-```
-
-### More
-
-More examples can be found in the [eval.test](eval.test.ts)

package/src/expr/eval.test.ts

@@ -1,198 +0,0 @@
-import { pipe, result } from "../fp";
-import { Path } from "../selector/future";
-import { selectorToVal } from "../selector/future/SelectorProxy";
-import { Source } from "../source";
-import { evaluate } from "./eval";
-import { parse } from "./parser";
-
-const sources = {
-  "/app/text": "text1",
-  "/numbers": [0, 1, 2],
-  "/articles": [{ title: "title1" }, { title: "title2" }],
-  "/app/blogs": [
-    { title: "blog1", text: "text1" },
-    { title: "blog2", text: "text2" },
-  ],
-};
-
-const EvalTestCases: {
-  expr: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  expected: result.Result<{ val: Source; [Path]: any }, any>;
-  focus?: boolean; // use focus to specify a single test case
-}[] = [
-  {
-    expr: `'hello world'`,
-    expected: result.ok({ val: "hello world", [Path]: undefined }),
-  },
-  {
-    expr: `(val '/numbers')`,
-    expected: result.ok({ val: [0, 1, 2], [Path]: "/numbers" }),
-  },
-  {
-    expr: `('hello world')`,
-    expected: result.ok({ val: "hello world", [Path]: undefined }),
-  },
-  {
-    expr: `()`,
-    expected: result.ok({ val: null, [Path]: undefined }),
-  },
-  {
-    expr: `(eq 'value' 'show me')`,
-    expected: result.ok({ val: false, [Path]: undefined }),
-  },
-  {
-    expr: `(eq 'value' 'value')`,
-    expected: result.ok({ val: true, [Path]: undefined }),
-  },
-  {
-    expr: `!(andThen 'value' 'show me')`,
-    expected: result.ok({ val: "show me", [Path]: undefined }),
-  },
-  {
-    expr: `!(andThen '' ('do NOT show me'))`,
-    expected: result.ok({ val: "", [Path]: undefined }),
-  },
-  {
-    expr: `!(andThen 'text1' @[0,0])`,
-    expected: result.ok({ val: "text1", [Path]: undefined }),
-  },
-  {
-    expr: `(json '1')`,
-    expected: result.ok({ val: 1, [Path]: undefined }),
-  },
-  {
-    expr: `(json '"1"')`,
-    expected: result.ok({ val: "1", [Path]: undefined }),
-  },
-  {
-    expr: `(json '{"foo": "bar"}')`,
-    expected: result.ok({ val: { foo: "bar" }, [Path]: undefined }),
-  },
-  {
-    expr: `(json '\${(json '1')}')`,
-    expected: result.ok({ val: 1, [Path]: undefined }),
-  },
-  {
-    expr: `(json '\${(json '"1"')}')`,
-    expected: result.ok({ val: "1", [Path]: undefined }),
-  },
-  {
-    expr: `(json '{"foo": \${(json '"1"')}}')`,
-    expected: result.ok({
-      val: {
-        foo: "1",
-      },
-      [Path]: undefined,
-    }),
-  },
-  {
-    expr: `(json '\${(val '/numbers')}')`,
-    expected: result.ok({
-      val: sources["/numbers"],
-      [Path]: "/numbers",
-    }),
-  },
-  {
-    expr: `('test' (json '{ "test": \${((json '0') (val '/numbers'))} }'))`,
-    expected: result.ok({
-      val: 0,
-      [Path]: "/numbers.0",
-    }),
-  },
-  {
-    expr: `((json '1') ('foo' (json '{"foo": \${(val '/numbers')}}')))`,
-    expected: result.ok({ val: 1, [Path]: "/numbers.1" }),
-  },
-  {
-    expr: `(length (val '/numbers'))`,
-    expected: result.ok({
-      val: sources["/numbers"].length,
-      [Path]: undefined,
-    }),
-  },
-  {
-    expr: `('0' (val '/articles'))`,
-    expected: result.ok({
-      val: sources["/articles"][0],
-      [Path]: "/articles.0",
-    }),
-  },
-  {
-    expr: `!(map (val '/articles') @[0,0])`,
-    expected: result.ok({
-      val: sources["/articles"].map((v) => v),
-      [Path]: "/articles",
-    }),
-  },
-  {
-    expr: `('0' !(map (val '/articles') ('title' @[0,0])))`,
-    expected: result.ok({
-      val: sources["/articles"].map((v) => v["title"])[0],
-      [Path]: '/articles.0."title"',
-    }),
-  },
-  {
-    expr: `!(map (val '/articles') ('title' @[0,0]))`,
-    expected: result.ok({
-      val: sources["/articles"].map((v) => v["title"]),
-      [Path]: "/articles",
-    }),
-  },
-  {
-    expr: `(eq !(andThen (val '/app/text') ()) 'foo')`,
-    expected: result.ok({
-      val: false,
-      [Path]: undefined,
-    }),
-  },
-  {
-    expr: `!(filter (val '/app/blogs') (eq ('title' @[0,0]) 'blog1'))`,
-    expected: result.ok({
-      val: [
-        {
-          text: "text1",
-          title: "blog1",
-        },
-      ],
-      [Path]: "/app/blogs",
-    }),
-  },
-  {
-    expr: `(json '{"title": \${()}}')`,
-    expected: result.ok({
-      val: {
-        title: null,
-      },
-
-      [Path]: undefined,
-    }),
-  },
-];
-
-describe("eval", () => {
-  test.each(
-    EvalTestCases.filter(({ focus }) =>
-      EvalTestCases.some((v) => v.focus) ? focus : true
-    )
-  )('evaluate: "$expr"', ({ expr, expected }) => {
-    const parseRes = parse(expr);
-    if (result.isErr(parseRes)) {
-      return expect(parseRes).toHaveProperty("value");
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(
-      pipe(
-        evaluate(
-          parseRes.value,
-          (path) => {
-            return sources[path as keyof typeof sources];
-          },
-          []
-        ),
-        result.map((v) => selectorToVal(v))
-      )
-    ).toStrictEqual(expected);
-  });
-  //
-});