@danielx/civet 0.4.16 → 0.4.18

package/README.md

@@ -47,25 +47,6 @@ createCompilerHost := (options: CompilerOptions, moduleSearchLocations : string[
     fileCache[fileName]
 ```
 
-ESBuild Plugin
----
-
-```coffee
-esbuild = require "esbuild"
-civetPlugin = require "@danielx/civet/esbuild-plugin"
-
-esbuild.build
-  entryPoints: ['source/main.civet']
-  bundle: true
-  platform: 'node'
-  outfile: 'dist/main.js'
-  plugins: [
-    civetPlugin
-  ]
-.catch -> process.exit 1
-
-```
-
 Things Kept from CoffeeScript
 ---
 
@@ -73,7 +54,7 @@ Things Kept from CoffeeScript
 - `or` -> `||`
 - `and` -> `&&`
 - `loop` -> `while(true)`
-- `unless` conditional (without the `else`)
+- `unless exp` -> `if(!exp)`
 - `until condition` -> `while(!condition)`
 - Object literal syntax
   ```coffee
@@ -99,31 +80,39 @@ Things Kept from CoffeeScript
 - Multiple `,` separated `case`/`when` expressions
 - `else` -> `default` in `switch`
 - Array slices `list[0...2]` -> `list.slice(0, 2)`
-- Slice assignment `numbers[3..6] = [-3, -4, -5, -6]`
+- Slice assignment `numbers[3..6] = [-3, -4, -5, -6]` -> `numbers.splice(3, 4, ...[-3, -4, -5, -6])`
 - Implicit returns
 - Simplified number method calls `1.toFixed()` -> `1..toFixed()`
+- `if`/`switch` expressions
+- Destructuring object assignment doesn't require being wrapped in parens at the statement level `{a, b} = c` -> `({a, b} = c)`
 - JSX 😿
 
 Things Removed from CoffeeScript
 ---
 
-- `on/yes/off/no` (use `true/false`, or `"civet coffeeCompat"` to add them back)
-- `isnt` (use `!==`)
-- `not` (use `!`)
+- 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"`)
+- `not` (use `!`, `"civet coffeeCompat"`, or `"civet coffeeNot"`)
+  - `not instanceof` (use `!(a instanceof b)`)
+  - `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)
-- `for from` (use JS `for of`)
+- `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"`)
 - `and=`, `or=` (don't mix and match words and symbols)
 - `a ? b` (use `a ?? b`, though it doesn't check for undeclared variables)
+- `a of b` (use `a in b` matching JS, or `"civet coffeeCompat"`, or `"civet coffeeOf"`)
 - Iteration expression results
 - Backtick embedded JS (replaced by template literals)
 - Will likely add later
   - Optional assignment `x?.y = 3` -> `x != null ? x.y = 3 : undefined`
-  - `switch` expressions
-  - `if` expressions
-  - Implicit `var` declarations (in compat mode only)
+  - Loop expressions (at least in compatibility mode)
+  - Conditional assignment `a?[x] = 3` -> `a ? a[x] = 3 : undefined`
 - Might add later
   - Braceless inline objects `x = coolStory: true`
-  - Comprensions
   - `///` Heregexp
   - Ranges `[0...10]`
   - Rest parameter in any assignment position
@@ -136,12 +125,12 @@ Things Changed from CoffeeScript
 - `!=` -> `!=` rather than `!==` (can be kept with `"civet coffeeCompat"`)
 - `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`
 - `x?.y` now compiles to `x?.y` rather than the `if typeof x !== 'undefined' && x !== null` if check
 - Existential `x?` -> `(x != null)` no longer checks for undeclared variables.
 - `x?()` -> `x?.()` instead of `if (typeof x === 'function') { x() }`
 - Backtick embedded JS has been replaced with JS template literals.
 - No longer allowing multiple postfix `if/unless` on the same line (use `&&` or `and` to combine conditions).
-- No `else` block on `unless` (negate condition and use `if`)
 - `#{}` interpolation in `""` strings only when `"civet coffeeCompat"` or `"civet coffeeInterpolation"`
 - Expanded chained comparisons to work on more operators `a in b instanceof C` -> `a in b && b instanceof C`
 - Postfix iteration/conditionals always wrap the statement [#5431](https://github.com/jashkenas/coffeescript/issues/5431)
@@ -192,12 +181,14 @@ Things Added that CoffeeScript didn't
   - Private identifiers `#id`
 - Convenience for ES6+ Features
   - Const assignment shorthand `a := b` -> `const a = b`; `{a, b} := c` -> `const {a, b} = c`
-  - `<` as `extends` shorthand
   - `@#id` -> `this.#id` shorthand for private identifiers
   - `import` shorthand `x from ./x` -> `import x from "./x"`
-  - `\`\`\`` Block Template Strings remove leading indentation for clarity
+  - Triple backtick Template Strings remove leading indentation for clarity
   - Class constructor shorthand `@( ... )`
   - ClassStaticBlock `@ { ... }`
+  - `<` as `extends` shorthand
+- Short function block syntax like [Ruby symbol to proc](https://ruby-doc.org/core-3.1.2/Symbol.html#method-i-to_proc), [Crystal](https://crystal-lang.org/reference/1.6/syntax_and_semantics/blocks_and_procs.html#short-one-parameter-syntax), [Elm record access](https://elm-lang.org/docs/records#access)
+  `x.map &.name` -> `x.map(a => a.name)`, `x.map &.profile?.name[0...3]` -> `x.map(a => a.profile?.name[0...3])`
 - Postfix loop `run() loop` -> `while(true) run()`
 - Shebang line is kept unmodified in output
   ```civet
@@ -214,12 +205,13 @@ Things Changed from ES6
   behave more differently than they already do is bad. Passing an anonymous function to an
   application without parens is also convenient.
 - `for(i of x) ...` defaults to const declaration -> `for(const i of x) ...`
-- Disallow comma operator in conditionals. `if x, y`
-- Comma operator in case/when becomes multiple conditions.
+- Disallow comma operator in conditionals and many other places. `if x, y` is not allowed.
+- Comma operator in `case`/`when` instead becomes multiple conditions.
 - Numbers can't end with a dot (otherwise would be ambiguous with CoffeeScript slices `y[0..x]`). This also implies that you can't access properties
 of numbers with `1..toString()` use `1.toString()` instead. When exponent follows a dot it is treated as a property access since an exponent
 could be a valid property `1.e10` -> `1..e10`. The workaround is to add a trailing zero `1.0e10` or remove the dot before the exponent `1e10`.
 - Additional reserved words `and`, `or`, `loop`, `until`, `unless`
+- No whitespace between unary operators and operands. Mandatory whitespace between condition and ternary `?` ex. `x ? a : b` since `x?` is the unary existential operator.
 
 CoffeeScript Compatibility
 ---
@@ -231,6 +223,7 @@ coffeeBooleans (yes/no/on/off)
 coffeeComment  (# single line comments)
 coffeeEq       (`==` -> `===`, `!=` -> `!==`)
 coffeeInterpolation (`"a string with {myVar}"`)
+coffeeIsnt     (`isnt` -> `!==`)
 ```
 
 You can use these with `"civet coffeeCompat"` to opt in to all or use them bit by bit with `"civet coffeeComment coffeeEq coffeeInterpolation"`.