@danielx/civet 0.4.19-pre.1 → 0.4.19-pre.2

package/README.md

@@ -79,6 +79,7 @@ Things Kept from CoffeeScript
 - `when` inside `switch` automatically breaks
 - Multiple `,` separated `case`/`when` expressions
 - `else` -> `default` in `switch`
+- Range literals `[0...10]`, `[a..b]`, `[x - 2 .. x + 2]`
 - Array slices `list[0...2]` -> `list.slice(0, 2)`
 - Slice assignment `numbers[3..6] = [-3, -4, -5, -6]` -> `numbers.splice(3, 4, ...[-3, -4, -5, -6])`
 - Implicit returns
@@ -90,6 +91,10 @@ Things Kept from CoffeeScript
 Things Removed from CoffeeScript
 ---
 
+Most of these can be enabled by adding a [`"civet coffeeCompat"` directive prologue](#coffeescript-compatibility) to the top of your file.
+The goal is to provide a very high level of compatibility with existing CoffeeScript code while offering a fine grained migration path to modern
+Civet.
+
 - Implicit `var` declarations (use `civet coffeeCompat` or `"civet autoVar"`)
 - `on/yes/off/no` (use `true/false`, `"civet coffeeCompat"`, or `"civet coffeeBooleans"` to add them back)
 - `isnt` (use `!==`, `"civet coffeeCompat"`, or `"civet coffeeIsnt"`)
@@ -98,7 +103,7 @@ Things Removed from CoffeeScript
   - `not in`
   - `not of`
   - NOTE: CoffeeScript `not` precedence is dubious. `not a < b` should be equivalent to `!(a < b)` but it is in fact `!a < b`
-- `do` keyword (replaced with JS `do`, invoke using existing `(-> ...)()` syntax)
+- `do` keyword (replaced with JS `do`, invoke using existing `(-> ...)()` syntax, `"civet coffeeCompat"`, or `"civet coffeeDo"`)
 - `for from` (use JS `for of`, `"civet coffeeCompat"`, or `"civet coffeeForLoops"`)
 - `for own of` (use JS `for in` and check manually, switch to `Map#keys/values/entries`, or use `Object.create(null)`, or `"civet coffeeCompat"`, or `"civet coffeeForLoops"`)
 - `for ... when <condition>` (use `continue if exp` inside loop, `"civet coffeeCompat"`, or `"civet coffeeForLoops"`)
@@ -114,15 +119,14 @@ Things Removed from CoffeeScript
 - Might add later
   - Braceless inline objects `x = coolStory: true`
   - `///` Heregexp
-  - Ranges `[0...10]`
   - Rest parameter in any assignment position
   - Multiple slice assignment `otherNumbers[0...] = numbers[3..6] = [-3, -4, -5, -6]`
 
 Things Changed from CoffeeScript
 ---
 
-- `==` -> `==` rather than `===` (can be kept with `"civet coffeeCompat"`)
-- `!=` -> `!=` rather than `!==` (can be kept with `"civet coffeeCompat"`)
+- `==` -> `==` rather than `===` (can be kept with `"civet coffeeCompat"` or `"civet coffeeEq"`)
+- `!=` -> `!=` rather than `!==` (can be kept with `"civet coffeeCompat"` or `"civet coffeeEq"`)
 - `for in` and `for of` are no longer swapped and become their JS equivalents.
 - `a...` is now `...a` just like JS
 - `a in b` is now `a in b` rather than `b.indexOf(a) >= 0`
@@ -193,7 +197,9 @@ Things Added that CoffeeScript didn't
   - function call `x.map &.callback a, b` -> `x.map($ => $.callback(a, b))`
   - unary operators `x.map !!&`, -> `x.map($ => !!$)`
   - binary operators `x.map &+1` -> `x.map($ => $+1)`
-- Postfix loop `run() loop` -> `while(true) run()`
+- CoffeeScript improvements
+  - Postfix loop `run() loop` -> `while(true) run()`
+  - Character range literals `["a".."z"]`, `['f'..'a']`, `['0'..'9']`
 - Shebang line is kept unmodified in output
   ```civet
   #!./node_modules/.bin/ts-node
@@ -224,11 +230,16 @@ CoffeeScript Compatibility
 Civet provides a compatability prologue directive that aims to be 97+% compatible with existing CoffeeScript2 code (still a work in progress).
 
 ```
+autoVar        (declare implicit vars based on assignment to undeclared identifiers)
 coffeeBooleans (yes/no/on/off)
 coffeeComment  (# single line comments)
+coffeeDo       ( `do ->`, disables ES6 do/while)
 coffeeEq       (`==` -> `===`, `!=` -> `!==`)
+coffeeForLoops (for in, of, from loops behavie like they do in CoffeeScript 2)
 coffeeInterpolation (`"a string with {myVar}"`)
 coffeeIsnt     (`isnt` -> `!==`)
+coffeeNot      (`not` -> "!") (currently doesn't support `not instanceof`, `not in`, `not of`)
+coffeeOf       (`a of b` -> `a in b`)
 ```
 
 You can use these with `"civet coffeeCompat"` to opt in to all or use them bit by bit with `"civet coffeeComment coffeeEq coffeeInterpolation"`.

package/dist/browser.js

@@ -1227,7 +1227,7 @@ var Civet = (() => {
           return result;
         }
       });
-      var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
         var ws = $3;
         var exp = $4;
         module.insertTrimmingSpace(ws, "");
@@ -2568,12 +2568,59 @@ var Civet = (() => {
         const inclusive = range.token === "..";
         range.token = ",";
         if (s.type === "Literal" && e.type === "Literal") {
-          const start = JSON.parse(s.raw);
-          const end = JSON.parse(e.raw);
-          const step = end > start ? 1 : -1;
-          const length = Math.abs(end - start) + (inclusive ? 1 : 0);
-          if (length <= 20) {
-            return Array.from({ length }, (_2, i) => start + i * step).join(", ");
+          let start, end;
+          if (s.raw[0] === "'") {
+            start = s.raw.match(/^'(.*)'$/)[1];
+          } else {
+            start = JSON.parse(s.raw);
+          }
+          if (e.raw[0] === "'") {
+            end = e.raw.match(/^'(.*)'$/)[1];
+          } else {
+            end = JSON.parse(e.raw);
+          }
+          if (typeof start !== typeof end) {
+            throw new Error("Range start and end must be of the same type");
+          }
+          if (typeof start === "string") {
+            if (start.length !== 1 || end.length !== 1) {
+              throw new Error("String range start and end must be a single character");
+            }
+            const startCode = start.charCodeAt(0);
+            const endCode = end.charCodeAt(0);
+            const step = startCode < endCode ? 1 : -1;
+            const length = Math.abs(endCode - startCode) + (inclusive ? 1 : 0);
+            if (length <= 26) {
+              return {
+                type: "RangeExpression",
+                children: ["[", Array.from({ length }, (_2, i) => JSON.stringify(String.fromCharCode(startCode + i * step))).join(", "), "]"],
+                inclusive,
+                start: s,
+                end: e
+              };
+            } else {
+              const inclusiveAdjust2 = inclusive ? " + 1" : "";
+              const children2 = ["((s, e) => {let step = e > s ? 1 : -1; return Array.from({length: Math.abs(e - s)", inclusiveAdjust2, "}, (_, i) => String.fromCharCode(s + i * step))})(", startCode.toString(), ws, range, endCode.toString(), ")"];
+              return {
+                type: "RangeExpression",
+                children: children2,
+                inclusive,
+                start: s,
+                end: e
+              };
+            }
+          } else if (typeof start === "number") {
+            const step = end > start ? 1 : -1;
+            const length = Math.abs(end - start) + (inclusive ? 1 : 0);
+            if (length <= 20) {
+              return {
+                type: "RangeExpression",
+                children: ["[", Array.from({ length }, (_2, i) => start + i * step).join(", "), "]"],
+                inclusive,
+                start: s,
+                end: e
+              };
+            }
           }
         }
         const inclusiveAdjust = inclusive ? " + 1" : "";

package/dist/main.js

@@ -1226,7 +1226,7 @@ var require_parser = __commonJS({
         return result;
       }
     });
-    var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
       var ws = $3;
       var exp = $4;
       module2.insertTrimmingSpace(ws, "");
@@ -2567,12 +2567,59 @@ var require_parser = __commonJS({
       const inclusive = range.token === "..";
       range.token = ",";
       if (s.type === "Literal" && e.type === "Literal") {
-        const start = JSON.parse(s.raw);
-        const end = JSON.parse(e.raw);
-        const step = end > start ? 1 : -1;
-        const length = Math.abs(end - start) + (inclusive ? 1 : 0);
-        if (length <= 20) {
-          return Array.from({ length }, (_2, i) => start + i * step).join(", ");
+        let start, end;
+        if (s.raw[0] === "'") {
+          start = s.raw.match(/^'(.*)'$/)[1];
+        } else {
+          start = JSON.parse(s.raw);
+        }
+        if (e.raw[0] === "'") {
+          end = e.raw.match(/^'(.*)'$/)[1];
+        } else {
+          end = JSON.parse(e.raw);
+        }
+        if (typeof start !== typeof end) {
+          throw new Error("Range start and end must be of the same type");
+        }
+        if (typeof start === "string") {
+          if (start.length !== 1 || end.length !== 1) {
+            throw new Error("String range start and end must be a single character");
+          }
+          const startCode = start.charCodeAt(0);
+          const endCode = end.charCodeAt(0);
+          const step = startCode < endCode ? 1 : -1;
+          const length = Math.abs(endCode - startCode) + (inclusive ? 1 : 0);
+          if (length <= 26) {
+            return {
+              type: "RangeExpression",
+              children: ["[", Array.from({ length }, (_2, i) => JSON.stringify(String.fromCharCode(startCode + i * step))).join(", "), "]"],
+              inclusive,
+              start: s,
+              end: e
+            };
+          } else {
+            const inclusiveAdjust2 = inclusive ? " + 1" : "";
+            const children2 = ["((s, e) => {let step = e > s ? 1 : -1; return Array.from({length: Math.abs(e - s)", inclusiveAdjust2, "}, (_, i) => String.fromCharCode(s + i * step))})(", startCode.toString(), ws, range, endCode.toString(), ")"];
+            return {
+              type: "RangeExpression",
+              children: children2,
+              inclusive,
+              start: s,
+              end: e
+            };
+          }
+        } else if (typeof start === "number") {
+          const step = end > start ? 1 : -1;
+          const length = Math.abs(end - start) + (inclusive ? 1 : 0);
+          if (length <= 20) {
+            return {
+              type: "RangeExpression",
+              children: ["[", Array.from({ length }, (_2, i) => start + i * step).join(", "), "]"],
+              inclusive,
+              start: s,
+              end: e
+            };
+          }
         }
       }
       const inclusiveAdjust = inclusive ? " + 1" : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.4.19-pre.1",
+  "version": "0.4.19-pre.2",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "exports": {