Increase perforance by a few %

- by rewriting some "map" functions to for loops
- using "?." syntax instead of ||{} in find
- hoisting regexes & functions

Author: Jacob Groß

src/_makeChunks.mjs

@@ -1,49 +1,63 @@
+const _stringRegex = /string/;
+
+const _replaceString = (type) =>
+  _stringRegex.test(type) ? '"__par__"' : "__par__";
+
+const _isLastRegex = /^("}|})/;
+
+// 3 possibilities after arbitrary property:
+// - ", => non-last string property
+// - , => non-last non-string property
+// - " => last string property
+const _matchStartRe = /^(\"\,|\,|\")/;
+
 /**
  * @param {string} str - prepared string already validated.
  * @param {array} queue - queue containing the property name to match
  * (used for building dynamic regex) needed for the preparation of
  * chunks used in different scenarios.
  */
-export default (str, queue) => str
-  // Matching prepared properties and replacing with target with or without
-  // double quotes.
-  // => Avoiding unnecessary concatenation of doublequotes during serialization.
-  .replace(/"\w+__sjs"/gm, type => (/string/.test(type) ? '"__par__"' : '__par__'))
-  .split('__par__')
-  .map((chunk, index, chunks) => {
+const _makeChunks = (str, queue) => {
+  const chunks = str
+      // Matching prepared properties and replacing with target with or without
+      // double quotes.
+      // => Avoiding unnecessary concatenation of doublequotes during serialization.
+      .replace(/"\w+__sjs"/gm, _replaceString)
+      .split("__par__"),
+    result = [];
+
+  for (let i = 0; i < chunks.length; ++i) {
+    const chunk = chunks[i];
+
     // Using dynamic regex to ensure that only the correct property
     // at the end of the string it's actually selected.
     // => e.g. ,"a":{"a": => ,"a":{
-    const matchProp = `("${(queue[index] || {}).name}":(\"?))$`;
-    const matchWhenLast = `(\,?)${matchProp}`;
+    const matchProp = `("${(queue[i] || {}).name}":(\"?))$`;
 
     // Check if current chunk is the last one inside a nested property
-    const isLast = /^("}|})/.test(chunks[index + 1] || '');
+    const isLast = _isLastRegex.test(chunks[i + 1] || "");
 
     // If the chunk is the last one the `isUndef` case should match
     // the preceding comma too.
-    const matchPropRe = new RegExp(isLast ? matchWhenLast : matchProp);
-
-    // 3 possibilities after arbitrary property:
-    // - ", => non-last string property
-    // - , => non-last non-string property
-    // - " => last string property
-    const matchStartRe = /^(\"\,|\,|\")/;
+    const matchPropRe = new RegExp(isLast ? `(\,?)${matchProp}` : matchProp);
 
-    return {
+    result.push({
       // notify that the chunk preceding the current one has not
       // its corresponding property undefined.
       // => This is a V8 optimization as it's way faster writing
       // the value of a property than writing the entire property.
       flag: false,
       pure: chunk,
       // Without initial part
-      prevUndef: chunk.replace(matchStartRe, ''),
+      prevUndef: chunk.replace(_matchStartRe, ""),
       // Without property chars
-      isUndef: chunk.replace(matchPropRe, ''),
+      isUndef: chunk.replace(matchPropRe, ""),
       // Only remaining chars (can be zero chars)
-      bothUndef: chunk
-        .replace(matchStartRe, '')
-        .replace(matchPropRe, ''),
-    };
-  });
+      bothUndef: chunk.replace(_matchStartRe, "").replace(matchPropRe, ""),
+    });
+  }
+
+  return result;
+};
+
+export { _makeChunks };

src/_makeQueue.mjs

@@ -1,37 +1,41 @@
-import { _find } from './_utils';
+import { __find, _find } from "./_utils.mjs";
+
+const _sjsRegex = /__sjs/;
+
+function _prepareQueue(originalSchema, queue, obj, acc = []) {
+  if (_sjsRegex.test(obj)) {
+    const usedAcc = [...acc];
+    const find = __find(usedAcc);
+    const { serializer } = find(originalSchema);
+
+    queue.push({
+      serializer,
+      find,
+      name: acc[acc.length - 1],
+    });
+    return;
+  }
+
+  // Recursively going deeper.
+  // NOTE: While going deeper, the current prop is pushed into the accumulator
+  // to keep track of the position inside of the object.
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i];
+    _prepareQueue(originalSchema, queue, obj[key], [...acc, key]);
+  }
+}
 
 /**
  * @param {object} preparedSchema - schema already validated
  * with modified prop values to avoid clashes.
  * @param {object} originalSchema - User provided schema
  * => contains array stringification serializers that are lost during preparation.
  */
-export default (preparedSchema, originalSchema) => {
+const _makeQueue = (preparedSchema, originalSchema) => {
   const queue = [];
-
-  // Defining a function inside an other function is slow.
-  // However it's OK for this use case as the queue creation is not time critical.
-  (function scoped(obj, acc = []) {
-    if (/__sjs/.test(obj)) {
-      const usedAcc = Array.from(acc);
-      const find = _find(usedAcc);
-      const { serializer } = find(originalSchema);
-
-      queue.push({
-        serializer,
-        find,
-        name: acc[acc.length - 1],
-      });
-      return;
-    }
-
-    // Recursively going deeper.
-    // NOTE: While going deeper, the current prop is pushed into the accumulator
-    // to keep track of the position inside of the object.
-    return Object
-      .keys(obj)
-      .map(prop => scoped(obj[prop], [...acc, prop]));
-  })(preparedSchema);
-
+  _prepareQueue(originalSchema, queue, preparedSchema);
   return queue;
 };
+
+export { _makeQueue };

src/_prepare.js renamed to src/_prepare.mjs

@@ -1,3 +1,7 @@
+const _stringifyCallback = (_, value) => {
+  if (!value.isSJS) return value;
+  return `${value.type}__sjs`;
+};
 
 /**
  * `_prepare` - aims to normalize the schema provided by the user.
@@ -6,17 +10,13 @@
  * @param {object} schema - user provided schema
  */
 const _prepare = (schema) => {
-  const preparedString = JSON.stringify(schema, (_, value) => {
-    if (!value.isSJS) return value;
-    return `${value.type}__sjs`;
-  });
-
-  const preparedSchema = JSON.parse(preparedString);
+  const _preparedString = JSON.stringify(schema, _stringifyCallback);
+  const _preparedSchema = JSON.parse(_preparedString);
 
   return {
-    preparedString,
-    preparedSchema,
+    _preparedString,
+    _preparedSchema,
   };
 };
 
-export default _prepare;
+export { _prepare };

src/_select.js renamed to src/_select.mjs

@@ -8,10 +8,10 @@
  * @param {any} value - value to serialize.
  * @param {number} index - position inside the queue.
  */
-const _select = chunks => (value, index) => {
+const _select = (chunks) => (value, index) => {
   const chunk = chunks[index];
 
-  if (typeof value !== 'undefined') {
+  if (value !== undefined) {
     if (chunk.flag) {
       return chunk.prevUndef + value;
     }
@@ -28,4 +28,4 @@ const _select = chunks => (value, index) => {
   return chunk.isUndef;
 };
 
-export default _select;
+export { _select };

src/_utils.mjs

@@ -1,4 +1,3 @@
-
 /**
  * `_find` is a super fast deep property finder.
  * It dynamically build the function needed to reach the desired
@@ -11,16 +10,23 @@
  * @param {array} path - path to reach object property.
  */
 const _find = (path) => {
-  const { length } = path;
+  let str = 'obj';
+
+  for (let i = 0; i < path.length; ++i) {
+    str = `(${str}||{}).${path[i]}`;
+  }
 
+  return eval(`(obj=>${str})`);
+};
+
+const __find = (path) => {
   let str = 'obj';
 
-  for (let i = 0; i < length; i++) {
-    str = str.replace(/^/, '(');
-    str += ` || {}).${path[i]}`;
+  for (let i = 0; i < path.length; ++i) {
+    str += `?.['${path[i]}']`;
   }
 
-  return eval(`((obj) => ${str})`);
+  return eval(`(obj=>${str})`);
 };
 
 /**
@@ -35,51 +41,54 @@ const _makeArraySerializer = (serializer) => {
     return (array) => {
       // Stringifying more complex array using the provided sjs schema
       let acc = '';
-      const { length } = array;
-      for (let i = 0; i < length - 1; i++) {
+      const len = array.length - 1;
+      for (let i = 0; i < len; ++i) {
         acc += `${serializer(array[i])},`;
       }
 
       // Prevent slice for removing unnecessary comma.
-      acc += serializer(array[length - 1]);
+      acc += serializer(array[len]);
       return `[${acc}]`;
     };
   }
 
   return array => JSON.stringify(array);
 };
 
-const TYPES = [
-  'number',
-  'string',
-  'boolean',
-  'array',
-  'null',
-];
+const TYPES = ['number', 'string', 'boolean', 'array', 'null'];
 
-const attr = (type, serializer) => {
-  if (!TYPES.includes(type)) {
-    throw new Error(`Expected one of: "number", "string", "boolean", "null". received "${type}" instead`);
+/*#__PURE__*/
+function checkType(type) {
+  if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'production' && !TYPES.includes(type)) {
+    throw new Error(
+      `Expected one of: "number", "string", "boolean", "array", "null". received "${type}" instead`,
+    );
   }
+}
+
+/**
+ * @param type number|string|boolean|array|null
+ * @param serializer
+ * @returns
+ */
+const attr = (type, serializer) => {
+  /*#__PURE__*/checkType(type);
 
   const usedSerializer = serializer || (value => value);
 
   return {
     isSJS: true,
     type,
-    serializer: type === 'array'
-      ? _makeArraySerializer(serializer)
-      : usedSerializer,
+    serializer:
+      type === 'array' ? _makeArraySerializer(serializer) : usedSerializer,
   };
 };
 
 // Little utility for escaping convenience.
 // => if no regex is provided, a default one will be used.
-const defaultRegex = new RegExp('\\n|\\r|\\t|\\"|\\\\', 'gm');
-const escape = (regex = defaultRegex) => str => str.replace(regex, char => '\\' + char);
+const _defaultRegex = new RegExp('\\n|\\r|\\t|\\"|\\\\', 'gm');
+const _escapeCallback = char => '\\' + char;
+const escape = (regex = _defaultRegex) => str => str.replace(regex, _escapeCallback);
+
+export { __find, _find, escape, attr };
 
-export {
-  _find,
-  escape,
-  attr,
-};

src/sjs.mjs

@@ -1,26 +1,26 @@
-import _prepare from './_prepare';
-import _makeQueue from './_makeQueue';
-import _makeChunks from './_makeChunks';
-import _select from './_select';
-import { attr, escape } from './_utils';
+import { _prepare } from "./_prepare.mjs";
+import { _makeQueue } from "./_makeQueue.mjs";
+import { _makeChunks } from "./_makeChunks.mjs";
+import { _select } from "./_select.mjs";
+import { attr, escape } from "./_utils.mjs";
 
 // Doing a lot of preparation work before returning the final function responsible for
 // the stringification.
 const sjs = (schema) => {
-  const { preparedString, preparedSchema } = _prepare(schema);
+  const { _preparedString, _preparedSchema } = _prepare(schema);
 
   // Providing preparedSchema for univocal correspondence between created queue and chunks.
   // Provided original schema to keep track of the original properties that gets destroied
   // during schema preparation => e.g. array stringification method.
-  const queue = _makeQueue(preparedSchema, schema);
-  const chunks = _makeChunks(preparedString, queue);
+  const queue = _makeQueue(_preparedSchema, schema);
+  const chunks = _makeChunks(_preparedString, queue);
   const selectChunk = _select(chunks);
 
-  const { length } = queue;
+  const length = queue.length;
 
   // Exposed function
   return (obj) => {
-    let temp = '';
+    let temp = "";
 
     // Ditching old implementation for a **MUCH** faster while
     let i = 0;
@@ -31,7 +31,7 @@ const sjs = (schema) => {
 
       temp += selectChunk(serializer(raw), i);
 
-      i += 1;
+      ++i;
     }
 
     const { flag, pure, prevUndef } = chunks[chunks.length - 1];
@@ -40,8 +40,4 @@ const sjs = (schema) => {
   };
 };
 
-export {
-  sjs,
-  attr,
-  escape,
-};
+export { sjs, attr, escape };