solid-js 1.5.0-beta.2 → 1.5.0-beta.3

package/web/dist/dev.cjs

@@ -207,6 +207,9 @@ function dynamicProperty(props, key) {
 function innerHTML(parent, content) {
   !solidJs.sharedConfig.context && (parent.innerHTML = content);
 }
+function use(fn, element, arg) {
+  return solidJs.untrack(() => fn(element, arg));
+}
 function insert(parent, accessor, marker, initial) {
   if (marker !== undefined && !initial) initial = [];
   if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
@@ -414,6 +417,7 @@ function insertExpression(parent, value, current, marker, unwrapArray) {
       return () => current;
     }
     if (solidJs.sharedConfig.context) {
+      if (!array.length) return current;
       for (let i = 0; i < array.length; i++) {
         if (array[i].parentNode) return current = array;
       }
@@ -690,3 +694,4 @@ exports.ssrHydrationKey = ssrHydrationKey;
 exports.ssrStyle = ssrStyle;
 exports.style = style;
 exports.template = template;
+exports.use = use;

package/web/dist/dev.js

@@ -1,4 +1,4 @@
-import { createMemo, createRoot, createRenderEffect, sharedConfig, enableHydration, createSignal, onCleanup, splitProps, $DEVCOMP, untrack } from 'solid-js';
+import { createMemo, createRoot, createRenderEffect, sharedConfig, untrack, enableHydration, createSignal, onCleanup, splitProps, $DEVCOMP } from 'solid-js';
 export { ErrorBoundary, For, Index, Match, Show, Suspense, SuspenseList, Switch, createComponent, createRenderEffect as effect, getOwner, mergeProps } from 'solid-js';
 
 const booleans = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"];
@@ -204,6 +204,9 @@ function dynamicProperty(props, key) {
 function innerHTML(parent, content) {
   !sharedConfig.context && (parent.innerHTML = content);
 }
+function use(fn, element, arg) {
+  return untrack(() => fn(element, arg));
+}
 function insert(parent, accessor, marker, initial) {
   if (marker !== undefined && !initial) initial = [];
   if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
@@ -411,6 +414,7 @@ function insertExpression(parent, value, current, marker, unwrapArray) {
       return () => current;
     }
     if (sharedConfig.context) {
+      if (!array.length) return current;
       for (let i = 0; i < array.length; i++) {
         if (array[i].parentNode) return current = array;
       }
@@ -591,4 +595,4 @@ function Dynamic(props) {
   });
 }
 
-export { Aliases, Assets, ChildProperties, DOMElements, DelegatedEvents, Dynamic, Assets as HydrationScript, NoHydration, Portal, PropAliases, Properties, SVGElements, SVGNamespace, addEventListener, assign, classList, className, clearDelegatedEvents, delegateEvents, dynamicProperty, escape, generateHydrationScript, getHydrationKey, getNextElement, getNextMarker, getNextMatch, hydrate, innerHTML, insert, isServer, memo, render, renderToStream, renderToString, renderToStringAsync, resolveSSRNode, runHydrationEvents, setAttribute, setAttributeNS, spread, ssr, ssrAttribute, ssrClassList, ssrElement, ssrHydrationKey, ssrStyle, style, template };
+export { Aliases, Assets, ChildProperties, DOMElements, DelegatedEvents, Dynamic, Assets as HydrationScript, NoHydration, Portal, PropAliases, Properties, SVGElements, SVGNamespace, addEventListener, assign, classList, className, clearDelegatedEvents, delegateEvents, dynamicProperty, escape, generateHydrationScript, getHydrationKey, getNextElement, getNextMarker, getNextMatch, hydrate, innerHTML, insert, isServer, memo, render, renderToStream, renderToString, renderToStringAsync, resolveSSRNode, runHydrationEvents, setAttribute, setAttributeNS, spread, ssr, ssrAttribute, ssrClassList, ssrElement, ssrHydrationKey, ssrStyle, style, template, use };

package/web/dist/server.cjs

@@ -13,225 +13,255 @@ const Aliases = {
   htmlFor: "for"
 };
 
-var chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
-var unsafeChars = /[<>\b\f\n\r\t\0\u2028\u2029]/g;
-var reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
-var escaped = {
-  '<': '\\u003C',
-  '>': '\\u003E',
-  '/': '\\u002F',
-  '\\': '\\\\',
-  '\b': '\\b',
-  '\f': '\\f',
-  '\n': '\\n',
-  '\r': '\\r',
-  '\t': '\\t',
-  '\0': '\\0',
-  '\u2028': '\\u2028',
-  '\u2029': '\\u2029'
-};
-var objectProtoOwnPropertyNames = Object.getOwnPropertyNames(Object.prototype).sort().join('\0');
-function devalue(value) {
-  var counts = new Map();
-  function walk(thing) {
-    if (typeof thing === 'function') {
-      throw new Error("Cannot stringify a function");
+const {
+  hasOwnProperty
+} = Object.prototype;
+const REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
+const REF_START_CHARS_LEN = REF_START_CHARS.length;
+const REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
+const REF_CHARS_LEN = REF_CHARS.length;
+const STACK = [];
+const BUFFER = [""];
+let ASSIGNMENTS = new Map();
+let INDEX_OR_REF = new WeakMap();
+let REF_COUNT = 0;
+BUFFER.pop();
+function stringify(root) {
+  if (writeProp(root, "")) {
+    let result = BUFFER[0];
+    for (let i = 1, len = BUFFER.length; i < len; i++) {
+      result += BUFFER[i];
     }
-    if (counts.has(thing)) {
-      counts.set(thing, counts.get(thing) + 1);
-      return;
+    if (REF_COUNT) {
+      if (ASSIGNMENTS.size) {
+        let ref = INDEX_OR_REF.get(root);
+        if (typeof ref === "number") {
+          ref = toRefParam(REF_COUNT++);
+          result = ref + "=" + result;
+        }
+        for (const [assignmentRef, assignments] of ASSIGNMENTS) {
+          result += ";" + assignments + assignmentRef;
+        }
+        result += ";return " + ref;
+        ASSIGNMENTS = new Map();
+      } else {
+        result = "return " + result;
+      }
+      result = "(function(" + refParamsString() + "){" + result + "}())";
+    } else if (root && root.constructor === Object) {
+      result = "(" + result + ")";
     }
-    counts.set(thing, 1);
-    if (!isPrimitive(thing)) {
-      var type = getType(thing);
-      switch (type) {
-        case 'Number':
-        case 'String':
-        case 'Boolean':
-        case 'Date':
-        case 'RegExp':
-          return;
-        case 'Array':
-          thing.forEach(walk);
-          break;
-        case 'Set':
-        case 'Map':
-          Array.from(thing).forEach(walk);
-          break;
-        default:
-          var proto = Object.getPrototypeOf(thing);
-          if (proto !== Object.prototype && proto !== null && Object.getOwnPropertyNames(proto).sort().join('\0') !== objectProtoOwnPropertyNames) {
-            throw new Error("Cannot stringify arbitrary non-POJOs");
-          }
-          if (Object.getOwnPropertySymbols(thing).length > 0) {
-            throw new Error("Cannot stringify POJOs with symbolic keys");
-          }
-          Object.keys(thing).forEach(function (key) {
-            return walk(thing[key]);
-          });
+    BUFFER.length = 0;
+    INDEX_OR_REF = new WeakMap();
+    return result;
+  }
+  return "void 0";
+}
+function writeProp(cur, accessor) {
+  switch (typeof cur) {
+    case "string":
+      BUFFER.push(quote(cur, 0));
+      break;
+    case "number":
+      BUFFER.push(cur + "");
+      break;
+    case "boolean":
+      BUFFER.push(cur ? "!0" : "!1");
+      break;
+    case "object":
+      if (cur === null) {
+        BUFFER.push("null");
+      } else {
+        const ref = getRef(cur, accessor);
+        switch (ref) {
+          case true:
+            return false;
+          case false:
+            switch (cur.constructor) {
+              case Object:
+                writeObject(cur);
+                break;
+              case Array:
+                writeArray(cur);
+                break;
+              case Date:
+                BUFFER.push('new Date("' + cur.toISOString() + '")');
+                break;
+              case RegExp:
+                BUFFER.push(cur + "");
+                break;
+              case Map:
+                BUFFER.push("new Map(");
+                writeArray(Array.from(cur));
+                BUFFER.push(")");
+                break;
+              case Set:
+                BUFFER.push("new Set(");
+                writeArray(Array.from(cur));
+                BUFFER.push(")");
+                break;
+              case undefined:
+                BUFFER.push("Object.assign(Object.create(null),");
+                writeObject(cur);
+                BUFFER.push("))");
+                break;
+              default:
+                return false;
+            }
+            break;
+          default:
+            BUFFER.push(ref);
+            break;
+        }
+      }
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+function writeObject(obj) {
+  let sep = "{";
+  STACK.push(obj);
+  for (const key in obj) {
+    if (hasOwnProperty.call(obj, key)) {
+      const val = obj[key];
+      const escapedKey = toObjectKey(key);
+      BUFFER.push(sep + escapedKey + ":");
+      if (writeProp(val, escapedKey)) {
+        sep = ",";
+      } else {
+        BUFFER.pop();
       }
     }
   }
-  walk(value);
-  var names = new Map();
-  Array.from(counts).filter(function (entry) {
-    return entry[1] > 1;
-  }).sort(function (a, b) {
-    return b[1] - a[1];
-  }).forEach(function (entry, i) {
-    names.set(entry[0], getName(i));
-  });
-  function stringify(thing) {
-    if (names.has(thing)) {
-      return names.get(thing);
+  if (sep === "{") {
+    BUFFER.push("{}");
+  } else {
+    BUFFER.push("}");
+  }
+  STACK.pop();
+}
+function writeArray(arr) {
+  BUFFER.push("[");
+  STACK.push(arr);
+  writeProp(arr[0], 0);
+  for (let i = 1, len = arr.length; i < len; i++) {
+    BUFFER.push(",");
+    writeProp(arr[i], i);
+  }
+  STACK.pop();
+  BUFFER.push("]");
+}
+function getRef(cur, accessor) {
+  let ref = INDEX_OR_REF.get(cur);
+  if (ref === undefined) {
+    INDEX_OR_REF.set(cur, BUFFER.length);
+    return false;
+  }
+  if (typeof ref === "number") {
+    ref = insertAndGetRef(cur, ref);
+  }
+  if (STACK.includes(cur)) {
+    const parent = STACK[STACK.length - 1];
+    let parentRef = INDEX_OR_REF.get(parent);
+    if (typeof parentRef === "number") {
+      parentRef = insertAndGetRef(parent, parentRef);
     }
-    if (isPrimitive(thing)) {
-      return stringifyPrimitive(thing);
+    ASSIGNMENTS.set(ref, (ASSIGNMENTS.get(ref) || "") + toAssignment(parentRef, accessor) + "=");
+    return true;
+  }
+  return ref;
+}
+function toObjectKey(name) {
+  const invalidIdentifierPos = getInvalidIdentifierPos(name);
+  return invalidIdentifierPos === -1 ? name : quote(name, invalidIdentifierPos);
+}
+function toAssignment(parent, key) {
+  return parent + (typeof key === "number" || key[0] === '"' ? "[" + key + "]" : "." + key);
+}
+function getInvalidIdentifierPos(name) {
+  let char = name[0];
+  if (!(char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "$" || char === "_")) {
+    return 0;
+  }
+  for (let i = 1, len = name.length; i < len; i++) {
+    char = name[i];
+    if (!(char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || char === "$" || char === "_")) {
+      return i;
     }
-    var type = getType(thing);
-    switch (type) {
-      case 'Number':
-      case 'String':
-      case 'Boolean':
-        return "Object(" + stringify(thing.valueOf()) + ")";
-      case 'RegExp':
-        return "new RegExp(" + stringifyString(thing.source) + ", \"" + thing.flags + "\")";
-      case 'Date':
-        return "new Date(" + thing.getTime() + ")";
-      case 'Array':
-        var members = thing.map(function (v, i) {
-          return i in thing ? stringify(v) : '';
-        });
-        var tail = thing.length === 0 || thing.length - 1 in thing ? '' : ',';
-        return "[" + members.join(',') + tail + "]";
-      case 'Set':
-      case 'Map':
-        return "new " + type + "([" + Array.from(thing).map(stringify).join(',') + "])";
+  }
+  return -1;
+}
+function quote(str, startPos) {
+  let result = "";
+  let lastPos = 0;
+  for (let i = startPos, len = str.length; i < len; i++) {
+    let replacement;
+    switch (str[i]) {
+      case '"':
+        replacement = '\\"';
+        break;
+      case "\\":
+        replacement = "\\\\";
+        break;
+      case "<":
+        replacement = "\\x3C";
+        break;
+      case "\n":
+        replacement = "\\n";
+        break;
+      case "\r":
+        replacement = "\\r";
+        break;
+      case "\u2028":
+        replacement = "\\u2028";
+        break;
+      case "\u2029":
+        replacement = "\\u2029";
+        break;
       default:
-        var obj = "{" + Object.keys(thing).map(function (key) {
-          return safeKey(key) + ":" + stringify(thing[key]);
-        }).join(',') + "}";
-        var proto = Object.getPrototypeOf(thing);
-        if (proto === null) {
-          return Object.keys(thing).length > 0 ? "Object.assign(Object.create(null)," + obj + ")" : "Object.create(null)";
-        }
-        return obj;
+        continue;
     }
+    result += str.slice(lastPos, i) + replacement;
+    lastPos = i + 1;
   }
-  var str = stringify(value);
-  if (names.size) {
-    var params_1 = [];
-    var statements_1 = [];
-    var values_1 = [];
-    names.forEach(function (name, thing) {
-      params_1.push(name);
-      if (isPrimitive(thing)) {
-        values_1.push(stringifyPrimitive(thing));
-        return;
-      }
-      var type = getType(thing);
-      switch (type) {
-        case 'Number':
-        case 'String':
-        case 'Boolean':
-          values_1.push("Object(" + stringify(thing.valueOf()) + ")");
-          break;
-        case 'RegExp':
-          values_1.push(thing.toString());
-          break;
-        case 'Date':
-          values_1.push("new Date(" + thing.getTime() + ")");
-          break;
-        case 'Array':
-          values_1.push("Array(" + thing.length + ")");
-          thing.forEach(function (v, i) {
-            statements_1.push(name + "[" + i + "]=" + stringify(v));
-          });
-          break;
-        case 'Set':
-          values_1.push("new Set");
-          statements_1.push(name + "." + Array.from(thing).map(function (v) {
-            return "add(" + stringify(v) + ")";
-          }).join('.'));
-          break;
-        case 'Map':
-          values_1.push("new Map");
-          statements_1.push(name + "." + Array.from(thing).map(function (_a) {
-            var k = _a[0],
-                v = _a[1];
-            return "set(" + stringify(k) + ", " + stringify(v) + ")";
-          }).join('.'));
-          break;
-        default:
-          values_1.push(Object.getPrototypeOf(thing) === null ? 'Object.create(null)' : '{}');
-          Object.keys(thing).forEach(function (key) {
-            statements_1.push("" + name + safeProp(key) + "=" + stringify(thing[key]));
-          });
-      }
-    });
-    statements_1.push("return " + str);
-    return "(function(" + params_1.join(',') + "){" + statements_1.join(';') + "}(" + values_1.join(',') + "))";
+  if (lastPos === startPos) {
+    result = str;
   } else {
-    return str;
-  }
-}
-function getName(num) {
-  var name = '';
-  do {
-    name = chars[num % chars.length] + name;
-    num = ~~(num / chars.length) - 1;
-  } while (num >= 0);
-  return reserved.test(name) ? name + "_" : name;
-}
-function isPrimitive(thing) {
-  return Object(thing) !== thing;
-}
-function stringifyPrimitive(thing) {
-  if (typeof thing === 'string') return stringifyString(thing);
-  if (thing === void 0) return 'void 0';
-  if (thing === 0 && 1 / thing < 0) return '-0';
-  var str = String(thing);
-  if (typeof thing === 'number') return str.replace(/^(-)?0\./, '$1.');
-  return str;
-}
-function getType(thing) {
-  return Object.prototype.toString.call(thing).slice(8, -1);
-}
-function escapeUnsafeChar(c) {
-  return escaped[c] || c;
-}
-function escapeUnsafeChars(str) {
-  return str.replace(unsafeChars, escapeUnsafeChar);
-}
-function safeKey(key) {
-  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escapeUnsafeChars(JSON.stringify(key));
-}
-function safeProp(key) {
-  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? "." + key : "[" + escapeUnsafeChars(JSON.stringify(key)) + "]";
-}
-function stringifyString(str) {
-  var result = '"';
-  for (var i = 0; i < str.length; i += 1) {
-    var char = str.charAt(i);
-    var code = char.charCodeAt(0);
-    if (char === '"') {
-      result += '\\"';
-    } else if (char in escaped) {
-      result += escaped[char];
-    } else if (code >= 0xd800 && code <= 0xdfff) {
-      var next = str.charCodeAt(i + 1);
-      if (code <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) {
-        result += char + str[++i];
-      } else {
-        result += "\\u" + code.toString(16).toUpperCase();
-      }
-    } else {
-      result += char;
-    }
+    result += str.slice(lastPos);
+  }
+  return '"' + result + '"';
+}
+function insertAndGetRef(obj, pos) {
+  const ref = toRefParam(REF_COUNT++);
+  INDEX_OR_REF.set(obj, ref);
+  if (pos) {
+    BUFFER[pos - 1] += ref + "=";
+  } else {
+    BUFFER[pos] = ref + "=" + BUFFER[pos];
+  }
+  return ref;
+}
+function refParamsString() {
+  let result = REF_START_CHARS[0];
+  for (let i = 1; i < REF_COUNT; i++) {
+    result += "," + toRefParam(i);
   }
-  result += '"';
+  REF_COUNT = 0;
   return result;
 }
+function toRefParam(index) {
+  let mod = index % REF_START_CHARS_LEN;
+  let ref = REF_START_CHARS[mod];
+  index = (index - mod) / REF_START_CHARS_LEN;
+  while (index > 0) {
+    mod = index % REF_CHARS_LEN;
+    ref += REF_CHARS[mod];
+    index = (index - mod) / REF_CHARS_LEN;
+  }
+  return ref;
+}
 
 const REPLACE_SCRIPT = `function $df(e,t,d,l){d=document.getElementById(e),(l=document.getElementById("pl-"+e))&&l.replaceWith(...d.childNodes),d.remove(),_$HY.set(e,t)}`;
 function renderToString(code, options = {}) {
@@ -244,7 +274,7 @@ function renderToString(code, options = {}) {
     nonce: options.nonce,
     writeResource(id, p, error) {
       if (error) return scripts += `_$HY.set("${id}", ${serializeError(p)});`;
-      scripts += `_$HY.set("${id}", ${devalue(p)});`;
+      scripts += `_$HY.set("${id}", ${stringify(p)});`;
     }
   };
   let html = injectAssets(solidJs.sharedConfig.context.assets, resolveSSRNode(escape(code())));
@@ -622,9 +652,9 @@ function serializeError(error) {
         fields[key] = value;
       }
     }
-    return `Object.assign(new Error(${devalue(error.message)}), ${devalue(fields)})`;
+    return `Object.assign(new Error(${stringify(error.message)}), ${stringify(fields)})`;
   }
-  return devalue(error);
+  return stringify(error);
 }
 function waitForFragments(registry, key) {
   for (const k of [...registry.keys()].reverse()) {
@@ -635,7 +665,7 @@ function waitForFragments(registry, key) {
   }
   return false;
 }
-function serializeSet(registry, key, value, serializer = devalue) {
+function serializeSet(registry, key, value, serializer = stringify) {
   const exist = registry.get(value);
   if (exist) return `_$HY.set("${key}", _$HY.r["${exist}"][0])`;
   value !== null && typeof value === "object" && registry.set(value, key);