0.5.6: no escaping for text inside <script> tag

Tao-VanJS · Tao-VanJS · commit 7e3663d09644 · 2024-03-09T22:20:44.000-08:00
diff --git a/README.md b/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.5/src/van-plate.js"
+import van from "https://deno.land/x/minivan@0.5.6/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.5/src/mini-van.js"
+import van from "https://deno.land/x/minivan@0.5.6/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.5.min.js"
+import van from "https://cdn.jsdelivr.net/gh/vanjs-org/mini-van/public/mini-van-0.5.6.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.5.nomodule.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/gh/vanjs-org/mini-van/public/mini-van-0.5.6.nomodule.min.js"></script>
 ```
 
-Alternative, you can download the files ([`mini-van-0.5.5.min.js`](https://vanjs.org/autodownload?file=mini-van-0.5.5.min.js), [`mini-van-0.5.5.nomodule.min.js`](https://vanjs.org/autodownload?file=mini-van-0.5.5.nomodule.min.js)) and serve them locally.
+Alternative, you can download the files ([`mini-van-0.5.6.min.js`](https://vanjs.org/autodownload?file=mini-van-0.5.6.min.js), [`mini-van-0.5.6.nomodule.min.js`](https://vanjs.org/autodownload?file=mini-van-0.5.6.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).
 
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "mini-van-plate",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "A minimalist template engine for DOM generation and manipulation, working for both client-side and server-side rendering",
   "files": [
     "src/mini-van.js",
diff --git a/public/mini-van-0.5.6.d.ts b/public/mini-van-0.5.6.d.ts
@@ -0,0 +1,74 @@
+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)>
+
+interface HasFirstChild {firstChild?: unknown}
+
+type NodeType<ElementType extends HasFirstChild> =
+  Omit<ElementType["firstChild"], "after" | "before" | "remove" | "replaceWith">
+
+export type ValidChildDomValue<ElementType extends HasFirstChild, TextNodeType> =
+  Primitive | ElementType | NodeType<ElementType> | TextNodeType | null | undefined
+
+export type BindingFunc<ElementType extends HasFirstChild, TextNodeType> =
+  | ((dom?: ElementType | TextNodeType) => ValidChildDomValue<ElementType, TextNodeType>)
+  | ((dom?: ElementType) => ElementType)
+
+export type ChildDom<ElementType extends HasFirstChild, TextNodeType> =
+  | ValidChildDomValue<ElementType, TextNodeType>
+  | StateView<Primitive | null | undefined>
+  | BindingFunc<ElementType, TextNodeType>
+  | readonly ChildDom<ElementType, TextNodeType>[]
+
+type AddFunc<ElementType extends HasFirstChild, TextNodeType> =
+  (dom: ElementType, ...children: readonly ChildDom<ElementType, TextNodeType>[]) => ElementType
+
+export type TagFunc<ElementType extends HasFirstChild, TextNodeType, ResultType = ElementType> =
+  (first?: Props | ChildDom<ElementType, TextNodeType>,
+    ...rest: readonly ChildDom<ElementType, TextNodeType>[]) => ResultType
+
+type Tags<ElementType extends HasFirstChild, 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]>
+}
+
+declare function state<T>(): State<T>
+declare function state<T>(initVal: T): State<T>
+
+export interface VanObj<ElementType extends HasFirstChild, TextNodeType> {
+  readonly state: typeof state
+  readonly derive: <T>(f: () => T) => State<T>
+  readonly add: AddFunc<ElementType, TextNodeType>
+  readonly tags: Tags<ElementType, TextNodeType> & ((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 extends HasFirstChild, TextNodeType>(doc: {
+    createElement(s: any): ElementType,
+    createTextNode(s: any): TextNodeType,
+  }) => VanObj<ElementType, TextNodeType>
+  readonly tags: BrowserTags & ((namespaceURI: string) => Tags<Element, Text>)
+}
+
+declare const van: Van
+
+export default van
diff --git a/public/mini-van-0.5.6.js b/public/mini-van-0.5.6.js
@@ -0,0 +1,47 @@
+/// <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 plainValue = (k, v) => {
+  let protoOfV = protoOf(v ?? 0)
+  return protoOfV === stateProto ? v.val :
+    protoOfV !== funcProto || k?.startsWith("on") ? 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 tag = (ns, 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)
+  }
+
+  let handler = ns => ({get: (_, name) => tag.bind(_undefined, ns, name)})
+  let tags = new Proxy(ns => new Proxy(tag, handler(ns)), handler())
+
+  return {
+    add, tags, state, derive: f => state(f()),
+    html: (...args) => "<!DOCTYPE html>" + tags.html(...args).outerHTML,
+  }
+}
+
+export default {"vanWithDoc": vanWithDoc,
+  ...vanWithDoc(typeof window !== "undefined" ? window.document : null)}
diff --git a/public/mini-van-0.5.6.min.d.ts b/public/mini-van-0.5.6.min.d.ts
@@ -0,0 +1,74 @@
+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)>
+
+interface HasFirstChild {firstChild?: unknown}
+
+type NodeType<ElementType extends HasFirstChild> =
+  Omit<ElementType["firstChild"], "after" | "before" | "remove" | "replaceWith">
+
+export type ValidChildDomValue<ElementType extends HasFirstChild, TextNodeType> =
+  Primitive | ElementType | NodeType<ElementType> | TextNodeType | null | undefined
+
+export type BindingFunc<ElementType extends HasFirstChild, TextNodeType> =
+  | ((dom?: ElementType | TextNodeType) => ValidChildDomValue<ElementType, TextNodeType>)
+  | ((dom?: ElementType) => ElementType)
+
+export type ChildDom<ElementType extends HasFirstChild, TextNodeType> =
+  | ValidChildDomValue<ElementType, TextNodeType>
+  | StateView<Primitive | null | undefined>
+  | BindingFunc<ElementType, TextNodeType>
+  | readonly ChildDom<ElementType, TextNodeType>[]
+
+type AddFunc<ElementType extends HasFirstChild, TextNodeType> =
+  (dom: ElementType, ...children: readonly ChildDom<ElementType, TextNodeType>[]) => ElementType
+
+export type TagFunc<ElementType extends HasFirstChild, TextNodeType, ResultType = ElementType> =
+  (first?: Props | ChildDom<ElementType, TextNodeType>,
+    ...rest: readonly ChildDom<ElementType, TextNodeType>[]) => ResultType
+
+type Tags<ElementType extends HasFirstChild, 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]>
+}
+
+declare function state<T>(): State<T>
+declare function state<T>(initVal: T): State<T>
+
+export interface VanObj<ElementType extends HasFirstChild, TextNodeType> {
+  readonly state: typeof state
+  readonly derive: <T>(f: () => T) => State<T>
+  readonly add: AddFunc<ElementType, TextNodeType>
+  readonly tags: Tags<ElementType, TextNodeType> & ((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 extends HasFirstChild, TextNodeType>(doc: {
+    createElement(s: any): ElementType,
+    createTextNode(s: any): TextNodeType,
+  }) => VanObj<ElementType, TextNodeType>
+  readonly tags: BrowserTags & ((namespaceURI: string) => Tags<Element, Text>)
+}
+
+declare const van: Van
+
+export default van
diff --git a/public/mini-van-0.5.6.min.js b/public/mini-van-0.5.6.min.js
diff --git a/public/mini-van-0.5.6.nomodule.js b/public/mini-van-0.5.6.nomodule.js
@@ -0,0 +1,43 @@
+(() => {
+  // 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 plainValue = (k, v) => {
+    let protoOfV = protoOf(v ?? 0);
+    return protoOfV === stateProto ? v.val : protoOfV !== funcProto || k?.startsWith("on") ? 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 tag = (ns, 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);
+    };
+    let handler = (ns) => ({ get: (_, name) => tag.bind(_undefined, ns, name) });
+    let tags = new Proxy((ns) => new Proxy(tag, handler(ns)), handler());
+    return {
+      add,
+      tags,
+      state,
+      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;
+})();
diff --git a/public/mini-van-0.5.6.nomodule.min.js b/public/mini-van-0.5.6.nomodule.min.js
diff --git a/public/mini-van.version b/public/mini-van.version
@@ -1 +1 @@
-0.5.5
+0.5.6
diff --git a/src/van-plate.js b/src/van-plate.js
@@ -47,7 +47,8 @@ const elementProto = {
     if (noChild[this.name]) return
     for (const c of this.children) {
       const plainC = plainValue(c)
-      protoOf(plainC) === elementProto ? plainC.renderToBuf(buf) : buf.push(escape(plainC.toString()))
+      protoOf(plainC) === elementProto ? plainC.renderToBuf(buf) :
+        buf.push((this.name === "script" ? x => x : escape)(plainC.toString()))
     }
     buf.push(`</${this.name}>`)
   },
diff --git a/test/deno/van-plate.test.ts b/test/deno/van-plate.test.ts
@@ -1,7 +1,7 @@
 import { assertEquals } from "https://deno.land/std@0.184.0/testing/asserts.ts";
 import van from "../../src/van-plate.js"
 
-const {a, body, br, button, div, head, input, hr, li, p, pre, span, title, ul} = van.tags
+const {a, body, br, button, div, head, hr, input, li, p, pre, script, span, title, ul} = van.tags
 
 Deno.test("tags", () => {
   assertEquals(div(
@@ -37,6 +37,10 @@ Deno.test("escapeAttr", () => {
   assertEquals(input({value: '"text"'}).render(), '<input value="&quot;text&quot;">')
 })
 
+Deno.test("don't escape script tag", () => {
+  assertEquals(script("console.log(a < b && c > d)").render(), "<script>console.log(a < b && c > d)</script>")
+})
+
 Deno.test("nested children", () => {
   assertEquals(ul([li("Item 1"), li("Item 2"), li("Item 3")]).render(),
     "<ul><li>Item 1</li><li>Item 2</li><li>Item 3</li></ul>")

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "mini-van-plate",`
`3`		`- "version": "0.5.5",`
	`3`	`+ "version": "0.5.6",`
`4`	`4`	`"description": "A minimalist template engine for DOM generation and manipulation, working for both client-side and server-side rendering",`
`5`	`5`	`"files": [`
`6`	`6`	`"src/mini-van.js",`