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

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())));
@@ -430,22 +460,16 @@ function renderToStream(code, options = {}) {
   };
 }
 function Assets(props) {
-  solidJs.sharedConfig.context.assets.push(() => NoHydration({
-    get children() {
-      return resolveSSRNode(props.children);
-    }
-  }));
-  return ssr(`%%$${solidJs.sharedConfig.context.assets.length - 1}%%`);
+  useAssets(() => props.children);
 }
 function HydrationScript(props) {
   const {
     nonce
   } = solidJs.sharedConfig.context;
-  solidJs.sharedConfig.context.assets.push(() => generateHydrationScript({
+  return ssr(generateHydrationScript({
     nonce,
     ...props
   }));
-  return ssr(`%%$${solidJs.sharedConfig.context.assets.length - 1}%%`);
 }
 function NoHydration(props) {
   const c = solidJs.sharedConfig.context;
@@ -591,6 +615,15 @@ function getHydrationKey() {
   const hydrate = solidJs.sharedConfig.context;
   return hydrate && !hydrate.noHydrate && `${hydrate.id}${hydrate.count++}`;
 }
+function useAssets(fn) {
+  solidJs.sharedConfig.context.assets.push(() => resolveSSRNode(fn()));
+}
+function getAssets() {
+  const assets = solidJs.sharedConfig.context.assets;
+  let out = "";
+  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
+  return out;
+}
 function generateHydrationScript({
   eventNames = ["click", "input"],
   nonce
@@ -598,10 +631,10 @@ function generateHydrationScript({
   return `<script${nonce ? ` nonce="${nonce}"` : ""}>var e,t;e=window._$HY||(_$HY={events:[],completed:new WeakSet,r:{}}),t=e=>e&&e.hasAttribute&&(e.hasAttribute("data-hk")?e:t(e.host&&e.host instanceof Node?e.host:e.parentNode)),["${eventNames.join('","')}"].forEach((o=>document.addEventListener(o,(o=>{let s=o.composedPath&&o.composedPath()[0]||o.target,a=t(s);a&&!e.completed.has(a)&&e.events.push([a,o])})))),e.init=(t,o)=>{e.r[t]=[new Promise(((e,t)=>o=e)),o]},e.set=(t,o,s)=>{(s=e.r[t])&&s[1](o),e.r[t]=[o]},e.unset=t=>{delete e.r[t]},e.load=t=>e.r[t];</script><!--xs-->`;
 }
 function injectAssets(assets, html) {
-  for (let i = 0; i < assets.length; i++) {
-    html = html.replace(`%%$${i}%%`, assets[i]());
-  }
-  return html;
+  if (!assets || !assets.length) return html;
+  let out = "";
+  for (let i = 0, len = assets.length; i < len; i++) out += assets[i]();
+  return html.replace(`<head>`, `<head>` + out);
 }
 function injectScripts(html, scripts, nonce) {
   const tag = `<script${nonce ? ` nonce="${nonce}"` : ""}>${scripts}</script>`;
@@ -622,9 +655,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 +668,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);
@@ -690,6 +723,37 @@ function pipeToWritable(code, writable, options = {}) {
   const stream = renderToStream(code, options);
   if (!options.onReady) stream.pipeTo(writable);
 }
+function ssrSpread(props, isSVG, skipChildren) {
+  let result = "";
+  if (props == null) return results;
+  if (typeof props === "function") props = props();
+  const keys = Object.keys(props);
+  let classResolved;
+  for (let i = 0; i < keys.length; i++) {
+    const prop = keys[i];
+    if (prop === "children") {
+      !skipChildren && console.warn(`SSR currently does not support spread children.`);
+      continue;
+    }
+    const value = props[prop];
+    if (prop === "style") {
+      result += `style="${ssrStyle(value)}"`;
+    } else if (prop === "class" || prop === "className" || prop === "classList") {
+      if (classResolved) continue;
+      let n;
+      result += `class="${(n = props.class) ? n + " " : ""}${(n = props.className) ? n + " " : ""}${ssrClassList(props.classList)}"`;
+      classResolved = true;
+    } else if (BooleanAttributes.has(prop)) {
+      if (value) result += prop;else continue;
+    } else if (value == undefined || prop === "ref" || prop.slice(0, 2) === "on") {
+      continue;
+    } else {
+      result += `${Aliases[prop] || prop}="${escape(value, true)}"`;
+    }
+    if (i !== keys.length - 1) result += " ";
+  }
+  return result;
+}
 
 const isServer = true;
 function spread() {}
@@ -754,6 +818,7 @@ exports.NoHydration = NoHydration;
 exports.Portal = Portal;
 exports.escape = escape;
 exports.generateHydrationScript = generateHydrationScript;
+exports.getAssets = getAssets;
 exports.getHydrationKey = getHydrationKey;
 exports.isServer = isServer;
 exports.pipeToNodeWritable = pipeToNodeWritable;
@@ -768,4 +833,6 @@ exports.ssrAttribute = ssrAttribute;
 exports.ssrClassList = ssrClassList;
 exports.ssrElement = ssrElement;
 exports.ssrHydrationKey = ssrHydrationKey;
+exports.ssrSpread = ssrSpread;
 exports.ssrStyle = ssrStyle;
+exports.useAssets = useAssets;