@rhinostone/swig-core 2.0.0-alpha.3

package/lib/tokentypes.js

@@ -0,0 +1,78 @@
+/**
+ * Lexer token type enum — the contract between a flavor-specific lexer
+ * and the shared TokenParser in @rhinostone/swig-core.
+ *
+ * Every frontend (native Swig, future Twig / Jinja2 / Django) supplies
+ * its own lexer with per-flavor regex rules. The TokenParser dispatches
+ * on these numeric IDs, so the IDs themselves must be stable across
+ * flavors. Flavor-specific extensions (e.g. Twig's `~` concatenation,
+ * `??` null-coalescing) may add new IDs above the reserved range, but
+ * must not re-use existing ones.
+ *
+ * Kept as a standalone module (rather than folded into the lexer) so
+ * that TokenParser can consume the enum without reaching into any
+ * frontend-specific code.
+ *
+ * @readonly
+ * @enum {number}
+ */
+module.exports = {
+  /** Whitespace */
+  WHITESPACE: 0,
+  /** Plain string */
+  STRING: 1,
+  /** Variable filter */
+  FILTER: 2,
+  /** Empty variable filter */
+  FILTEREMPTY: 3,
+  /** Function */
+  FUNCTION: 4,
+  /** Function with no arguments */
+  FUNCTIONEMPTY: 5,
+  /** Open parenthesis */
+  PARENOPEN: 6,
+  /** Close parenthesis */
+  PARENCLOSE: 7,
+  /** Comma */
+  COMMA: 8,
+  /** Variable */
+  VAR: 9,
+  /** Number */
+  NUMBER: 10,
+  /** Math operator */
+  OPERATOR: 11,
+  /** Open square bracket */
+  BRACKETOPEN: 12,
+  /** Close square bracket */
+  BRACKETCLOSE: 13,
+  /** Key on an object using dot-notation */
+  DOTKEY: 14,
+  /** Start of an array */
+  ARRAYOPEN: 15,
+  /** End of an array
+   * Currently unused
+  ARRAYCLOSE: 16, */
+  /** Open curly brace */
+  CURLYOPEN: 17,
+  /** Close curly brace */
+  CURLYCLOSE: 18,
+  /** Colon (:) */
+  COLON: 19,
+  /** JavaScript-valid comparator */
+  COMPARATOR: 20,
+  /** Boolean logic */
+  LOGIC: 21,
+  /** Boolean logic "not" */
+  NOT: 22,
+  /** true or false */
+  BOOL: 23,
+  /** Variable assignment */
+  ASSIGNMENT: 24,
+  /** Start of a method */
+  METHODOPEN: 25,
+  /** End of a method
+   * Currently unused
+  METHODEND: 26, */
+  /** Unknown type */
+  UNKNOWN: 100
+};

package/lib/utils.js

@@ -0,0 +1,184 @@
+var isArray;
+
+/**
+ * Strip leading and trailing whitespace from a string.
+ * @param  {string} input
+ * @return {string}       Stripped input.
+ */
+exports.strip = function (input) {
+  return input.replace(/^\s+|\s+$/g, '');
+};
+
+/**
+ * Test if a string starts with a given prefix.
+ * @param  {string} str    String to test against.
+ * @param  {string} prefix Prefix to check for.
+ * @return {boolean}
+ */
+exports.startsWith = function (str, prefix) {
+  return str.indexOf(prefix) === 0;
+};
+
+/**
+ * Test if a string ends with a given suffix.
+ * @param  {string} str    String to test against.
+ * @param  {string} suffix Suffix to check for.
+ * @return {boolean}
+ */
+exports.endsWith = function (str, suffix) {
+  return str.indexOf(suffix, str.length - suffix.length) !== -1;
+};
+
+/**
+ * Iterate over an array or object.
+ * @param  {array|object} obj Enumerable object.
+ * @param  {Function}     fn  Callback function executed for each item.
+ * @return {array|object}     The original input object.
+ */
+exports.each = function (obj, fn) {
+  var i, l;
+
+  if (isArray(obj)) {
+    i = 0;
+    l = obj.length;
+    for (i; i < l; i += 1) {
+      if (fn(obj[i], i, obj) === false) {
+        break;
+      }
+    }
+  } else {
+    for (i in obj) {
+      if (obj.hasOwnProperty(i)) {
+        if (fn(obj[i], i, obj) === false) {
+          break;
+        }
+      }
+    }
+  }
+
+  return obj;
+};
+
+/**
+ * Test if an object is an Array.
+ * @param {object} obj
+ * @return {boolean}
+ */
+exports.isArray = isArray = (Array.hasOwnProperty('isArray')) ? Array.isArray : function (obj) {
+  return (obj) ? (typeof obj === 'object' && Object.prototype.toString.call(obj).indexOf() !== -1) : false;
+};
+
+/**
+ * Test if an item in an enumerable matches your conditions.
+ * @param  {array|object}   obj   Enumerable object.
+ * @param  {Function}       fn    Executed for each item. Return true if your condition is met.
+ * @return {boolean}
+ */
+exports.some = function (obj, fn) {
+  var i = 0,
+    result,
+    l;
+  if (isArray(obj)) {
+    l = obj.length;
+
+    for (i; i < l; i += 1) {
+      result = fn(obj[i], i, obj);
+      if (result) {
+        break;
+      }
+    }
+  } else {
+    exports.each(obj, function (value, index) {
+      result = fn(value, index, obj);
+      return !(result);
+    });
+  }
+  return !!result;
+};
+
+/**
+ * Return a new enumerable, mapped by a given iteration function.
+ * @param  {object}   obj Enumerable object.
+ * @param  {Function} fn  Executed for each item. Return the item to replace the original item with.
+ * @return {object}       New mapped object.
+ */
+exports.map = function (obj, fn) {
+  var i = 0,
+    result = [],
+    l;
+
+  if (isArray(obj)) {
+    l = obj.length;
+    for (i; i < l; i += 1) {
+      result[i] = fn(obj[i], i);
+    }
+  } else {
+    for (i in obj) {
+      if (obj.hasOwnProperty(i)) {
+        result[i] = fn(obj[i], i);
+      }
+    }
+  }
+  return result;
+};
+
+/**
+ * Copy all of the properties in the source objects over to the destination object, and return the destination object. It's in-order, so the last source will override properties of the same name in previous arguments.
+ * @param {...object} arguments
+ * @return {object}
+ */
+exports.extend = function () {
+  var args = arguments,
+    target = args[0],
+    objs = (args.length > 1) ? Array.prototype.slice.call(args, 1) : [],
+    i = 0,
+    l = objs.length,
+    key,
+    obj;
+
+  for (i; i < l; i += 1) {
+    obj = objs[i] || {};
+    for (key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        target[key] = obj[key];
+      }
+    }
+  }
+  return target;
+};
+
+/**
+ * Get all of the keys on an object.
+ * @param  {object} obj
+ * @return {array}
+ */
+exports.keys = function (obj) {
+  if (!obj) {
+    return [];
+  }
+
+  if (Object.keys) {
+    return Object.keys(obj);
+  }
+
+  return exports.map(obj, function (v, k) {
+    return k;
+  });
+};
+
+/**
+ * Throw an error with possible line number and source file.
+ * @param  {string} message Error message
+ * @param  {number} [line]  Line number in template.
+ * @param  {string} [file]  Template file the error occured in.
+ * @throws {Error} No seriously, the point is to throw an error.
+ */
+exports.throwError = function (message, line, file) {
+  if (line) {
+    message += ' on line ' + line;
+  }
+  if (file) {
+    message += ' in file ' + file;
+  }
+  throw new Error(message + '.');
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@rhinostone/swig-core",
+  "version": "2.0.0-alpha.3",
+  "description": "Shared IR, backend, and runtime for the @rhinostone/swig family of template engines. First publish at 2.0.0-alpha.3 — see @rhinostone/swig #T14 (Phase 1 carve).",
+  "keywords": [
+    "template",
+    "templating",
+    "ir",
+    "swig",
+    "swig-core"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gina-io/swig.git",
+    "directory": "packages/swig-core"
+  },
+  "author": "Rhinostone <contact@gina.io>",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "engines": {
+    "node": ">=12"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}