0.5.2: Simplify type definitions.

Author: Tao-VanJS

README.md

@@ -154,7 +154,7 @@ Sample code:
 _Requires Deno `1.35` or later._
 
 ```typescript
-import van from "https://deno.land/x/minivan@0.5.0/src/van-plate.js"
+import van from "https://deno.land/x/minivan@0.5.2/src/van-plate.js"
 
 const {a, body, li, p, ul} = van.tags
 
@@ -195,7 +195,7 @@ _Requires Deno `1.35` or later._
 
 ```typescript
 import { DOMParser } from "https://deno.land/x/deno_dom@v0.1.38/deno-dom-wasm.ts"
-import van from "https://deno.land/x/minivan@0.5.0/src/mini-van.js"
+import van from "https://deno.land/x/minivan@0.5.2/src/mini-van.js"
 
 const document = new DOMParser().parseFromString("", "text/html")!
 const {tags, html} = van.vanWithDoc(document)
@@ -235,16 +235,16 @@ Preview via [CodeSandbox](https://codesandbox.io/p/sandbox/github/vanjs-org/vanj
 To get started on the client side, add the line below to your script:
 
 ```javascript
-import van from "https://cdn.jsdelivr.net/gh/vanjs-org/mini-van/public/mini-van-0.5.0.min.js"
+import van from "https://cdn.jsdelivr.net/gh/vanjs-org/mini-van/public/mini-van-0.5.2.min.js"
 ```
 
 To code without ES6 modules, add the following line to your HTML file instead:
 
 ```html
-<script type="text/javascript" src="https://cdn.jsdelivr.net/gh/vanjs-org/mini-van/public/mini-van-0.5.0.nomodule.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/gh/vanjs-org/mini-van/public/mini-van-0.5.2.nomodule.min.js"></script>
 ```
 
-Alternative, you can download the files ([`mini-van-0.5.0.min.js`](https://vanjs.org/autodownload?file=mini-van-0.5.0.min.js), [`mini-van-0.5.0.nomodule.min.js`](https://vanjs.org/autodownload?file=mini-van-0.5.0.nomodule.min.js)) and serve them locally.
+Alternative, you can download the files ([`mini-van-0.5.2.min.js`](https://vanjs.org/autodownload?file=mini-van-0.5.2.min.js), [`mini-van-0.5.2.nomodule.min.js`](https://vanjs.org/autodownload?file=mini-van-0.5.2.nomodule.min.js)) and serve them locally.
 
 You can find all relevant **Mini-Van** files in this [Download Table](https://vanjs.org/minivan#download-table).
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-van-plate",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "A minimalist template engine for DOM generation and manipulation, working for both client-side and server-side rendering",
   "files": [
     "src/mini-van.js",

package.json

@@ -0,0 +1,69 @@
+export interface State<T> {
+  val: T
+  readonly oldVal: T
+}
+
+// Defining readonly view of State<T> for covariance.
+// Basically we want StateView<string> to implement StateView<string | number>
+export type StateView<T> = Readonly<State<T>>
+
+export type Primitive = string | number | boolean | bigint
+
+export type PropValue = Primitive | ((e: any) => void) | null
+
+export type Props = Record<string, PropValue | StateView<PropValue> | (() => PropValue)>
+
+export type ValidChildDomValue<ElementType, TextNodeType> =
+  Primitive | ElementType | TextNodeType | null | undefined
+
+export type BindingFunc<ElementType, TextNodeType> =
+  | ((dom?: ElementType | TextNodeType) => ValidChildDomValue<ElementType, TextNodeType>)
+  | ((dom?: ElementType) => ElementType)
+
+export type ChildDom<ElementType, TextNodeType> =
+  | ValidChildDomValue<ElementType, TextNodeType>
+  | StateView<Primitive | null | undefined>
+  | BindingFunc<ElementType, TextNodeType>
+  | readonly ChildDom<ElementType, TextNodeType>[]
+
+type AddFunc<ElementType, TextNodeType> =
+  (dom: ElementType, ...children: readonly ChildDom<ElementType, TextNodeType>[]) => ElementType
+
+export type TagFunc<ElementType, TextNodeType, ResultType = ElementType> =
+  (first?: Props | ChildDom<ElementType, TextNodeType>,
+    ...rest: readonly ChildDom<ElementType, TextNodeType>[]) => ResultType
+
+type Tags<ElementType, TextNodeType> = Readonly<Record<string, TagFunc<ElementType, TextNodeType>>>
+
+// Tags type in browser context, which contains the signatures to tag functions that return
+// specialized DOM elements.
+type BrowserTags = Tags<Element, Text> & {
+  [K in keyof HTMLElementTagNameMap]: TagFunc<Element, Text, HTMLElementTagNameMap[K]>
+}
+
+export interface VanObj<ElementType, TextNodeType> {
+  readonly state: <T>(initVal: T) => State<T>
+  readonly val: <T>(s: T | StateView<T>) => T
+  readonly oldVal: <T>(s: T | StateView<T>) => T
+  readonly derive: <T>(f: () => T) => State<T>
+  readonly add: AddFunc<ElementType, TextNodeType>
+  readonly _: (f: () => PropValue) => () => PropValue
+  readonly tags: Tags<ElementType, TextNodeType>
+  readonly tagsNS: (namespaceURI: string) => Tags<ElementType, TextNodeType>
+
+  // Mini-Van specific API
+  html: (first?: Props | ChildDom<ElementType, TextNodeType>,
+    ...rest: readonly ChildDom<ElementType, TextNodeType>[]) => string
+}
+
+export interface Van extends VanObj<Element, Text> {
+  readonly vanWithDoc: <ElementType, TextNodeType>(doc: {
+    createElement(s: any): ElementType,
+    createTextNode(s: any): TextNodeType,
+  }) => VanObj<ElementType, TextNodeType>
+  readonly tags: BrowserTags
+}
+
+declare const van: Van
+
+export default van

public/mini-van-0.5.1.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="./mini-van.d.ts" />
+
+// This file consistently uses `let` keyword instead of `const` for reducing the bundle size.
+
+// Aliasing some builtin symbols to reduce the bundle size.
+let protoOf = Object.getPrototypeOf, _undefined, funcProto = protoOf(protoOf)
+
+let stateProto = {get oldVal() { return this.val }}, objProto = protoOf(stateProto)
+
+let state = initVal => ({__proto__: stateProto, val: initVal})
+
+let val = s => protoOf(s ?? 0) === stateProto ? s.val : s
+
+let plainValue = (k, v) => {
+  let protoOfV = protoOf(v ?? 0)
+  return protoOfV === stateProto ? v.val :
+    protoOfV === funcProto && (!k?.startsWith("on") || v._isBindingFunc) ? v() : v
+}
+
+let add = (dom, ...children) =>
+  (dom.append(...children.flat(Infinity)
+    .map(plainValue.bind(_undefined, _undefined))
+    .filter(c => c != _undefined)),
+  dom)
+
+let vanWithDoc = doc => {
+  let tagsNS = ns => new Proxy((name, ...args) => {
+    let [props, ...children] = protoOf(args[0] ?? 0) === objProto ? args : [{}, ...args]
+    let dom = ns ? doc.createElementNS(ns, name) : doc.createElement(name)
+    for (let [k, v] of Object.entries(props)) {
+      let plainV = plainValue(k, v)
+      // Disable setting attribute for function-valued properties (mostly event handlers),
+      // as they're usually not useful for SSR (server-side rendering).
+      protoOf(plainV) !== funcProto && dom.setAttribute(k, plainV)
+    }
+    return add(dom, ...children)
+  }, {get: (tag, name) => tag.bind(null, name)})
+
+  let tags = tagsNS()
+
+  return {
+    add, _: f => (f._isBindingFunc = 1, f), tags, tagsNS, state,
+    val, oldVal: val, derive: f => state(f()),
+    html: (...args) => "<!DOCTYPE html>" + tags.html(...args).outerHTML,
+  }
+}
+
+export default {"vanWithDoc": vanWithDoc,
+  ...vanWithDoc(typeof window !== "undefined" ? window.document : null)}

public/mini-van-0.5.1.js

@@ -0,0 +1,69 @@
+export interface State<T> {
+  val: T
+  readonly oldVal: T
+}
+
+// Defining readonly view of State<T> for covariance.
+// Basically we want StateView<string> to implement StateView<string | number>
+export type StateView<T> = Readonly<State<T>>
+
+export type Primitive = string | number | boolean | bigint
+
+export type PropValue = Primitive | ((e: any) => void) | null
+
+export type Props = Record<string, PropValue | StateView<PropValue> | (() => PropValue)>
+
+export type ValidChildDomValue<ElementType, TextNodeType> =
+  Primitive | ElementType | TextNodeType | null | undefined
+
+export type BindingFunc<ElementType, TextNodeType> =
+  | ((dom?: ElementType | TextNodeType) => ValidChildDomValue<ElementType, TextNodeType>)
+  | ((dom?: ElementType) => ElementType)
+
+export type ChildDom<ElementType, TextNodeType> =
+  | ValidChildDomValue<ElementType, TextNodeType>
+  | StateView<Primitive | null | undefined>
+  | BindingFunc<ElementType, TextNodeType>
+  | readonly ChildDom<ElementType, TextNodeType>[]
+
+type AddFunc<ElementType, TextNodeType> =
+  (dom: ElementType, ...children: readonly ChildDom<ElementType, TextNodeType>[]) => ElementType
+
+export type TagFunc<ElementType, TextNodeType, ResultType = ElementType> =
+  (first?: Props | ChildDom<ElementType, TextNodeType>,
+    ...rest: readonly ChildDom<ElementType, TextNodeType>[]) => ResultType
+
+type Tags<ElementType, TextNodeType> = Readonly<Record<string, TagFunc<ElementType, TextNodeType>>>
+
+// Tags type in browser context, which contains the signatures to tag functions that return
+// specialized DOM elements.
+type BrowserTags = Tags<Element, Text> & {
+  [K in keyof HTMLElementTagNameMap]: TagFunc<Element, Text, HTMLElementTagNameMap[K]>
+}
+
+export interface VanObj<ElementType, TextNodeType> {
+  readonly state: <T>(initVal: T) => State<T>
+  readonly val: <T>(s: T | StateView<T>) => T
+  readonly oldVal: <T>(s: T | StateView<T>) => T
+  readonly derive: <T>(f: () => T) => State<T>
+  readonly add: AddFunc<ElementType, TextNodeType>
+  readonly _: (f: () => PropValue) => () => PropValue
+  readonly tags: Tags<ElementType, TextNodeType>
+  readonly tagsNS: (namespaceURI: string) => Tags<ElementType, TextNodeType>
+
+  // Mini-Van specific API
+  html: (first?: Props | ChildDom<ElementType, TextNodeType>,
+    ...rest: readonly ChildDom<ElementType, TextNodeType>[]) => string
+}
+
+export interface Van extends VanObj<Element, Text> {
+  readonly vanWithDoc: <ElementType, TextNodeType>(doc: {
+    createElement(s: any): ElementType,
+    createTextNode(s: any): TextNodeType,
+  }) => VanObj<ElementType, TextNodeType>
+  readonly tags: BrowserTags
+}
+
+declare const van: Van
+
+export default van

public/mini-van-0.5.1.min.d.ts

@@ -0,0 +1,47 @@
+(() => {
+  // mini-van.js
+  var protoOf = Object.getPrototypeOf;
+  var _undefined;
+  var funcProto = protoOf(protoOf);
+  var stateProto = { get oldVal() {
+    return this.val;
+  } };
+  var objProto = protoOf(stateProto);
+  var state = (initVal) => ({ __proto__: stateProto, val: initVal });
+  var val = (s) => protoOf(s ?? 0) === stateProto ? s.val : s;
+  var plainValue = (k, v) => {
+    let protoOfV = protoOf(v ?? 0);
+    return protoOfV === stateProto ? v.val : protoOfV === funcProto && (!k?.startsWith("on") || v._isBindingFunc) ? v() : v;
+  };
+  var add = (dom, ...children) => (dom.append(...children.flat(Infinity).map(plainValue.bind(_undefined, _undefined)).filter((c) => c != _undefined)), dom);
+  var vanWithDoc = (doc) => {
+    let tagsNS = (ns) => new Proxy((name, ...args) => {
+      let [props, ...children] = protoOf(args[0] ?? 0) === objProto ? args : [{}, ...args];
+      let dom = ns ? doc.createElementNS(ns, name) : doc.createElement(name);
+      for (let [k, v] of Object.entries(props)) {
+        let plainV = plainValue(k, v);
+        protoOf(plainV) !== funcProto && dom.setAttribute(k, plainV);
+      }
+      return add(dom, ...children);
+    }, { get: (tag, name) => tag.bind(null, name) });
+    let tags = tagsNS();
+    return {
+      add,
+      _: (f) => (f._isBindingFunc = 1, f),
+      tags,
+      tagsNS,
+      state,
+      val,
+      oldVal: val,
+      derive: (f) => state(f()),
+      html: (...args) => "<!DOCTYPE html>" + tags.html(...args).outerHTML
+    };
+  };
+  var mini_van_default = {
+    "vanWithDoc": vanWithDoc,
+    ...vanWithDoc(typeof window !== "undefined" ? window.document : null)
+  };
+
+  // mini-van.forbundle.js
+  window.van = mini_van_default;
+})();

public/mini-van-0.5.1.min.js

@@ -0,0 +1,69 @@
+export interface State<T> {
+  val: T
+  readonly oldVal: T
+}
+
+// Defining readonly view of State<T> for covariance.
+// Basically we want StateView<string> to implement StateView<string | number>
+export type StateView<T> = Readonly<State<T>>
+
+export type Primitive = string | number | boolean | bigint
+
+export type PropValue = Primitive | ((e: any) => void) | null
+
+export type Props = Record<string, PropValue | StateView<PropValue> | (() => PropValue)>
+
+export type ValidChildDomValue<ElementType, TextNodeType> =
+  Primitive | ElementType | TextNodeType | null | undefined
+
+export type BindingFunc<ElementType, TextNodeType> =
+  | ((dom?: ElementType | TextNodeType) => ValidChildDomValue<ElementType, TextNodeType>)
+  | ((dom?: ElementType) => ElementType)
+
+export type ChildDom<ElementType, TextNodeType> =
+  | ValidChildDomValue<ElementType, TextNodeType>
+  | StateView<Primitive | null | undefined>
+  | BindingFunc<ElementType, TextNodeType>
+  | readonly ChildDom<ElementType, TextNodeType>[]
+
+type AddFunc<ElementType, TextNodeType> =
+  (dom: ElementType, ...children: readonly ChildDom<ElementType, TextNodeType>[]) => ElementType
+
+export type TagFunc<ElementType, TextNodeType, ResultType = ElementType> =
+  (first?: Props | ChildDom<ElementType, TextNodeType>,
+    ...rest: readonly ChildDom<ElementType, TextNodeType>[]) => ResultType
+
+type Tags<ElementType, TextNodeType> = Readonly<Record<string, TagFunc<ElementType, TextNodeType>>>
+
+// Tags type in browser context, which contains the signatures to tag functions that return
+// specialized DOM elements.
+type BrowserTags = Tags<Element, Text> & {
+  [K in keyof HTMLElementTagNameMap]: TagFunc<Element, Text, HTMLElementTagNameMap[K]>
+}
+
+export interface VanObj<ElementType, TextNodeType> {
+  readonly state: <T>(initVal: T) => State<T>
+  readonly val: <T>(s: T | StateView<T>) => T
+  readonly oldVal: <T>(s: T | StateView<T>) => T
+  readonly derive: <T>(f: () => T) => State<T>
+  readonly add: AddFunc<ElementType, TextNodeType>
+  readonly _: (f: () => PropValue) => () => PropValue
+  readonly tags: Tags<ElementType, TextNodeType>
+  readonly tagsNS: (namespaceURI: string) => Tags<ElementType, TextNodeType>
+
+  // Mini-Van specific API
+  html: (first?: Props | ChildDom<ElementType, TextNodeType>,
+    ...rest: readonly ChildDom<ElementType, TextNodeType>[]) => string
+}
+
+export interface Van extends VanObj<Element, Text> {
+  readonly vanWithDoc: <ElementType, TextNodeType>(doc: {
+    createElement(s: any): ElementType,
+    createTextNode(s: any): TextNodeType,
+  }) => VanObj<ElementType, TextNodeType>
+  readonly tags: BrowserTags
+}
+
+declare const van: Van
+
+export default van