npm - @valbuild/core - Versions diffs - 0.12.0 - Mend

@valbuild/core 0.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (100) hide show

package/CHANGELOG.md +0 -0
package/README.md +537 -0
package/dist/createClass-012eebbf.esm.js +109 -0
package/dist/createClass-a436dbfe.cjs.dev.js +116 -0
package/dist/createClass-de7426aa.cjs.prod.js +116 -0
package/dist/declarations/src/Json.d.ts +6 -0
package/dist/declarations/src/expr/eval.d.ts +19 -0
package/dist/declarations/src/expr/expr.d.ts +32 -0
package/dist/declarations/src/expr/index.d.ts +3 -0
package/dist/declarations/src/expr/parser.d.ts +8 -0
package/dist/declarations/src/expr/tokenizer.d.ts +7 -0
package/dist/declarations/src/fetchVal.d.ts +5 -0
package/dist/declarations/src/fp/array.d.ts +8 -0
package/dist/declarations/src/fp/index.d.ts +3 -0
package/dist/declarations/src/fp/result.d.ts +67 -0
package/dist/declarations/src/fp/util.d.ts +12 -0
package/dist/declarations/src/index.d.ts +32 -0
package/dist/declarations/src/initSchema.d.ts +57 -0
package/dist/declarations/src/initVal.d.ts +39 -0
package/dist/declarations/src/module.d.ts +38 -0
package/dist/declarations/src/patch/deref.d.ts +13 -0
package/dist/declarations/src/patch/index.d.ts +6 -0
package/dist/declarations/src/patch/json.d.ts +11 -0
package/dist/declarations/src/patch/operation.d.ts +59 -0
package/dist/declarations/src/patch/ops.d.ts +40 -0
package/dist/declarations/src/patch/parse.d.ts +19 -0
package/dist/declarations/src/patch/patch.d.ts +6 -0
package/dist/declarations/src/patch/util.d.ts +6 -0
package/dist/declarations/src/schema/array.d.ts +18 -0
package/dist/declarations/src/schema/boolean.d.ts +15 -0
package/dist/declarations/src/schema/i18n.d.ts +21 -0
package/dist/declarations/src/schema/image.d.ts +32 -0
package/dist/declarations/src/schema/index.d.ts +23 -0
package/dist/declarations/src/schema/literal.d.ts +17 -0
package/dist/declarations/src/schema/number.d.ts +22 -0
package/dist/declarations/src/schema/object.d.ts +25 -0
package/dist/declarations/src/schema/oneOf.d.ts +22 -0
package/dist/declarations/src/schema/richtext.d.ts +76 -0
package/dist/declarations/src/schema/string.d.ts +22 -0
package/dist/declarations/src/schema/union.d.ts +36 -0
package/dist/declarations/src/selector/SelectorProxy.d.ts +7 -0
package/dist/declarations/src/selector/array.d.ts +17 -0
package/dist/declarations/src/selector/boolean.d.ts +2 -0
package/dist/declarations/src/selector/file.d.ts +9 -0
package/dist/declarations/src/selector/i18n.d.ts +11 -0
package/dist/declarations/src/selector/index.d.ts +81 -0
package/dist/declarations/src/selector/number.d.ts +2 -0
package/dist/declarations/src/selector/object.d.ts +10 -0
package/dist/declarations/src/selector/primitive.d.ts +9 -0
package/dist/declarations/src/selector/remote.d.ts +7 -0
package/dist/declarations/src/selector/string.d.ts +2 -0
package/dist/declarations/src/source/file.d.ts +23 -0
package/dist/declarations/src/source/i18n.d.ts +29 -0
package/dist/declarations/src/source/index.d.ts +33 -0
package/dist/declarations/src/source/remote.d.ts +29 -0
package/dist/declarations/src/val/array.d.ts +9 -0
package/dist/declarations/src/val/index.d.ts +53 -0
package/dist/declarations/src/val/object.d.ts +9 -0
package/dist/declarations/src/val/primitive.d.ts +7 -0
package/dist/index-2f1631cf.cjs.prod.js +1031 -0
package/dist/index-55916dcd.esm.js +1000 -0
package/dist/index-b49a2c60.cjs.dev.js +1031 -0
package/dist/ops-6fae92a1.esm.js +12 -0
package/dist/ops-87cdbafc.cjs.dev.js +14 -0
package/dist/ops-ae4d1bc2.cjs.prod.js +14 -0
package/dist/result-26f67b40.cjs.prod.js +299 -0
package/dist/result-48320acd.cjs.dev.js +299 -0
package/dist/result-b96df128.esm.js +279 -0
package/dist/util-030d8a1f.cjs.prod.js +29 -0
package/dist/util-18613e99.esm.js +26 -0
package/dist/util-b213092b.cjs.dev.js +29 -0
package/dist/valbuild-core.cjs.d.ts +2 -0
package/dist/valbuild-core.cjs.d.ts.map +1 -0
package/dist/valbuild-core.cjs.dev.js +1276 -0
package/dist/valbuild-core.cjs.js +7 -0
package/dist/valbuild-core.cjs.prod.js +1276 -0
package/dist/valbuild-core.esm.js +1265 -0
package/expr/dist/valbuild-core-expr.cjs.d.ts +2 -0
package/expr/dist/valbuild-core-expr.cjs.d.ts.map +1 -0
package/expr/dist/valbuild-core-expr.cjs.dev.js +18 -0
package/expr/dist/valbuild-core-expr.cjs.js +7 -0
package/expr/dist/valbuild-core-expr.cjs.prod.js +18 -0
package/expr/dist/valbuild-core-expr.esm.js +3 -0
package/expr/package.json +4 -0
package/fp/dist/valbuild-core-fp.cjs.d.ts +2 -0
package/fp/dist/valbuild-core-fp.cjs.d.ts.map +1 -0
package/fp/dist/valbuild-core-fp.cjs.dev.js +13 -0
package/fp/dist/valbuild-core-fp.cjs.js +7 -0
package/fp/dist/valbuild-core-fp.cjs.prod.js +13 -0
package/fp/dist/valbuild-core-fp.esm.js +2 -0
package/fp/package.json +4 -0
package/package.json +43 -0
package/patch/dist/valbuild-core-patch.cjs.d.ts +2 -0
package/patch/dist/valbuild-core-patch.cjs.d.ts.map +1 -0
package/patch/dist/valbuild-core-patch.cjs.dev.js +443 -0
package/patch/dist/valbuild-core-patch.cjs.js +7 -0
package/patch/dist/valbuild-core-patch.cjs.prod.js +443 -0
package/patch/dist/valbuild-core-patch.esm.js +431 -0
package/patch/package.json +4 -0
package/tsconfig.json +7 -0

package/CHANGELOG.md ADDED Viewed

File without changes

package/README.md ADDED Viewed

@@ -0,0 +1,537 @@
+<p align="center">
+  <h1 align="center">Val</h1>
+  <p align="center">
+    ✨ <a href="https://app.val.build">https://app.val.build</a> ✨
+    <br/>
+    content - super-charged - hard-coded
+  </p>
+</p>
+# 🐉 HERE BE DRAGONS 🐉
+Val is PRE-ALPHA - MOST features are broken and in state of flux.
+This is released only for **INTERNAL** **TESTING** PURPOSES.
+## Table of contents
+- [Table of contents](#table-of-contents)
+- [Introduction](#introduction)
+- [Installation](#installation)
+- [Getting started](#getting-started)
+- [Concepts](#concepts)
+- [String](#string)
+- [Number](#number)
+- [Boolean](#boolean)
+- [Optional](#optional)
+- [Array](#array)
+- [Object](#object)
+- [Rich text](#richtext)
+- [Image](#image)
+- [Internalization](#internalization)
+- [Union](#union)
+- [One-of references](#one-of-references)
+- [Remote](#remote)
+- [Selector](#selector)
+## Introduction
+Val treats your content as code, but it remains fully editable.
+Val is built on top of TypeScript and Git, letting you use types, branches, version control (even rollbacks!) seamlessly.
+- Val is **TypeSafe**: being TypeScript-first means you see errors as you type. In addition you can **refactor**, find references and auto-complete content - just as if it was hard-coded. Safety means no more "add-only" content models, where your content model continues to expand because you hesitate to remove anything.
+- Version **control**: content is tied to commits, which means you can use branches and reverts just as you would normally do.
+- Val is **isomorphic**: if your content scales beyond your code base, Val lets you easily make it remote. Just add `.remote()` to your schema and Val will host your content - your components stays the same. Remote content are handled using immutable references, so remote content are tied to Git commits - rollbacks, branches works as before.
+- Contextual editing: Val is built from the ground up to support contextual editing. Editors can see Val content in the context of the app, and make edits directly there.
+- Full CMS: even hard-coded content has its drawbacks: i18n, images, rich text - Val supports all of these.
+- No signup required: **your** content is yours. Local development requires no sign ups and is free. When you are ready and editors needs access, you can sign up and without any changes to your code base. Head over to [https://app.val.build](https://app.val.build) to get started 🚀.
+## Installation
+- Make sure you have TypeScript 4.9+, Next 13+ (other meta frameworks will come), React 18+ (other frontend frameworks will come)
+- Install the packages:
+```sh
+npm install @valbuild/core @valbuild/react @valbuild/server
+```
+- Create your val.config.ts file:
+```ts
+// ./val.config.ts
+import { initVal } from "@valbuild/core";
+const { s, val } = initVal();
+export { s, val };
+```
+- Update tsconfig.json: enable strict mode and include the Val JSX transformer :
+```jsonc
+// ./tsconfig.json
+{
+  "compilerOptions": {
+    ///...
+    "strict": true,
+    ///...
+    "jsx": "react-jsx",
+    "jsxImportSource": "@valbuild/react"
+    //...
+  }
+  ///...
+}
+```
+- Enable contextual editing: setup Val endpoints
+```ts
+// ./pages/api/val/[...val].ts
+import { createRequestListener } from "@valbuild/server";
+import { NextApiHandler } from "next";
+const handler: NextApiHandler = createRequestListener("/api/val", {
+  valConfigPath: "./val.config",
+});
+export default handler;
+export const config = {
+  api: {
+    bodyParser: false,
+    externalResolver: true,
+  },
+};
+```
+- Enable contextual editing: Use the Val provider in a top-level layout file:
+```tsx
+// ./app/layout.tsx
+import { ValProvider } from "@valbuild/react";
+import "./globals.css";
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en">
+      {/*
+        <head /> will contain the components returned by the nearest parent
+        head.tsx. Find out more at https://beta.nextjs.org/docs/api-reference/file-conventions/head
+      */}
+      <head />
+      <body>
+        <ValProvider host="/api/val">{children}</ValProvider>
+      </body>
+    </html>
+  );
+}
+```
+## Getting started
+### Create your first Val content file
+Content defined in Val is always defined `.val.{ts|js}` files.
+They must export a default `val.content` where the first argument equals the path of the file relative to the `val.config.{js|ts}` file.
+```ts
+// ./app/example/blogs.val.ts
+import { s, val } from "src/val.config";
+export default val.content(
+  "/app/example/blogs", // <- NOTE: this must be the same path as the file
+  s.array(s.object({ title: s.string(), text: s.string() })),
+  [
+    {
+      title: "Title 1",
+      text: "Text 1",
+    },
+    {
+      title: "Title 2",
+      text: "Text 2",
+    },
+  ]
+);
+```
+### Use your content
+```tsx
+// /app/example/page.tsx
+import { NextPage } from "next";
+import { useVal } from "@valbuild/react";
+import blogsVal from "./blogs.val";
+import { val } from "val.config";
+const Home: NextPage = () => {
+  const blogs = useVal(blogsVal);
+  return (
+    <main>
+      <article>
+        {blogs.map((blog) => (
+          <section key={val.key(blog)}>
+            <h1>{blog.title}</h1>
+            <p>{blog.text}</p>
+          </section>
+        ))}
+      </article>
+    </main>
+  );
+};
+export default Home;
+```
+## Concepts
+`.val.{ts|js}` files **MUST** have a default export which is a ValModule. A ValModule is a special type of [Selector](#selectors). Selectors makes it possible to select a subset of content from a ValModule or a another Selector.
+Selectors can be turned to Val types using `useVal` or `fetchVal`.
+Val types is what you use in your components. It is a wrapper around underlying type that adds an id, which is used to automatically tag content in the DOM. You can always extract the underlying value from a Val using the `.val` property.
+### .val files
+`.val.{ts|js}` files are the files in which you store your content.
+They are evaluated when the content is run, therefore they have a specific set of requirements. They must have a default export that is `val.content`, they must have a `export const schema` with the Schema and they CANNOT import anything other than `val.config` and `@valbuild/core`.
+Example:
+```ts
+import { s, val } from "../val.config";
+export const schema = t.string();
+export default val.content(
+  "/file/path/relative/to/val/config",
+  schema,
+  "My string content"
+);
+```
+NOTE: IN THE FUTURE, they will be validated by the eslint-plugin.
+## String
+```ts
+import { s } from "./val.config";
+s.string(); // <- Schema<string>
+```
+### String selectors
+See [Selectors](#selector) for more info.
+### String `.eq`
+```ts
+useVal(stringVal.eq("")); // <- Val<boolean>
+```
+## Number
+```ts
+import { s } from "./val.config";
+s.number(); // <- Schema<number>
+```
+### Number selectors
+See [Selectors](#selector) for more info.
+### Number `.eq`
+```ts
+useVal(numberVal.eq(2)); // <- Val<boolean>
+```
+## Boolean
+```ts
+import { s } from "./val.config";
+s.boolean(); // <- Schema<boolean>
+```
+### Boolean selectors
+See [Selectors](#selector) for more info.
+### Boolean `.eq`
+```ts
+useVal(booleanVal.eq(true)); // <- Val<boolean>
+```
+## Optional
+All schema types can be optional. An optional schema creates a union of the type and `null`.
+```ts
+import { s } from "./val.config";
+s.string().optional(); // <- Schema<string | null>
+```
+### Selectors
+### Accessing the underlying type: `.andThen`
+To use and optional val, you can use the [.andThen](#andthen) selector.
+## Array
+```ts
+s.array(t.string());
+```
+### Selecting arrays
+### `.filter`
+TODO: text
+```ts
+useVal(myArray.filter((item) => item.title.eq("Title 1")));
+```
+### `.map`
+TODO:
+```ts
+useVal(myArray.map((item) => ({ test: item.title })));
+```
+## Object
+```ts
+s.object({
+  myProperty: s.string(),
+});
+```
+### Selecting objects
+You can select Selector objects almost as if they were normal objects. The exception is that you cannot use the spread (`...`) operator.
+Example:
+```ts
+useVal({ foo: myObjectVal.hello });
+```
+## RichText
+### RichText Schema
+```ts
+import { s } from "./val.config";
+s.richtext();
+```
+### Initializing RichText content
+To initialize some text content using a RichText schema, you can use follow the example below:
+```ts
+import { s, val } from "./val.config";
+// TODO: need some other way of doing this:
+export default val.content("/example/richtext.ts", s.richtext(), {
+  children: [
+    {
+      type: "paragraph",
+      version: 1,
+      indent: 0,
+      direction: "ltr",
+      format: "",
+      children: [
+        {
+          type: "text",
+          version: 1,
+          mode: "normal",
+          format: 0,
+          detail: 0,
+          style: "",
+          text: "TODO: update me",
+        },
+      ],
+    },
+  ],
+  direction: "ltr",
+  format: "",
+  indent: 0,
+  type: "root",
+  version: 1,
+});
+```
+### Render RichText
+You can use the `ValRichText` component to render content.
+```tsx
+"use client";
+import { useVal, ValRichText } from "@valbuild/react";
+import richtextVal from "./richtext";
+export default function Page() {
+  const richtext = useVal(richtextVal);
+  return <ValRichText>{richtext}</ValRichText>;
+}
+```
+## Image
+### Schema
+```ts
+s.image();
+```
+### Initializing image content
+Local images must be stored under the `.public` folder.
+```ts
+import { s, val } from "../val.config";
+export const schema = s.image();
+export default val.content("/image", schema, val.file("/public/myfile.jpg"));
+```
+NOTE: This will not validate, since images requires `width`, `height` and a `sha256` checksum. You can fix this validation in the UI by opening the image and clicking the Fix button.
+### Using images in components
+Images are transformed to object that have a `url` property which can be used to render them.
+Example:
+```tsx
+// in a Functional Component
+const image = useVal(imageVal);
+return <img src={image.url} />;
+```
+## Internalization
+**NOTE**: WORKS ONLY ON THE TYPE LEVEL
+To enable i18n, you must update your Val with the locales you want to enforce.
+Example:
+```ts
+// ./val.config.ts
+import { initVal } from "@valbuild/core";
+const { s, val } = initVal({
+  locales: {
+    required: ["en_US", "fr_FR"],
+    fallback: "en_US",
+  },
+});
+export { s, val };
+```
+## Union
+**NOTE**: WORKS ONLY ON THE TYPE LEVEL
+TODO: fill in.
+```ts
+s.union(
+  "type",
+  s.object({ type: s.literal("type1"), bar: s.string() }),
+  s.object({ type: s.literal("type2"), foo: s.number() })
+);
+```
+### Selecting unions
+### `.fold`
+TODO: description
+```ts
+useVal(myUnionVal.fold("type")({
+})
+```
+## One of references
+**NOTE**: Currently not possible to change from UI
+```ts
+```
+# Remote
+**NOTE**: WORKS ONLY ON THE TYPE LEVEL
+All schemas can be converted into `.remote`.
+TODO: add description.
+Example:
+```ts
+export const schema = s.object({ stuff: s.string() });
+export default val.content("/remote/example", schema, val.remote("REFERENCE"));
+```
+## Selector
+To select parts of a your content you should use Selectors.
+If you make the content `.remote`
+### `.andThen`
+All selectors can use `andThen` method which is similar to the `&&` operator. You can use this to only do operations on optionals that are defined. NOTE: only TRUTHY arguments are passed in to `andThen` (i.e. the empty string, `''` is NOT truthy).
+Given the example schema:
+```ts
+// ./maybeArray.val.ts
+//...
+export const schema = t.array(t.string()).optional();
+//...
+```
+```ts
+import maybeArrayVal from "./maybeArray.val";
+useVal(maybeArrayVal.andThen((array) => array.filter((v) => v.eq("foo"))));
+```

package/dist/createClass-012eebbf.esm.js ADDED Viewed

@@ -0,0 +1,109 @@
+import { b as _arrayLikeToArray, c as _unsupportedIterableToArray } from './result-b96df128.esm.js';
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _iterableToArrayLimit(arr, i) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+export { _classCallCheck as _, _createClass as a, _typeof as b, _slicedToArray as c, _toConsumableArray as d, _toPropertyKey as e };