refactor: remove old location methods

docs: update repl chapter to reflect new transpiler behavior

packages/core/pattern.mjs

@@ -488,52 +488,6 @@ export class Pattern {
     });
   }
 
-  /**
-   * Deprecated: Returns a new pattern with the given location information added to the
-   * context of every hap.
-   * @param {Number} start
-   * @param {Number} end
-   * @returns Pattern
-   * @noAutocomplete
-   */
-  withLocation(start, end) {
-    const location = {
-      start: { line: start[0], column: start[1], offset: start[2] },
-      end: { line: end[0], column: end[1], offset: end[2] },
-    };
-    return this.withContext((context) => {
-      const locations = (context.locations || []).concat([location]);
-      return { ...context, locations };
-    });
-  }
-
-  // DEPRECATED:
-  withMiniLocation(start, end) {
-    const offset = {
-      start: { line: start[0], column: start[1], offset: start[2] },
-      end: { line: end[0], column: end[1], offset: end[2] },
-    };
-    return this.withContext((context) => {
-      let locations = context.locations || [];
-      locations = locations.map(({ start, end }) => {
-        const colOffset = start.line === 1 ? offset.start.column : 0;
-        return {
-          start: {
-            ...start,
-            line: start.line - 1 + (offset.start.line - 1) + 1,
-            column: start.column - 1 + colOffset,
-          },
-          end: {
-            ...end,
-            line: end.line - 1 + (offset.start.line - 1) + 1,
-            column: end.column - 1 + colOffset,
-          },
-        };
-      });
-      return { ...context, locations };
-    });
-  }
-
   /**
    * Returns a new Pattern, which only returns haps that meet the given test.
    * @param {Function} hap_test - a function which returns false for haps to be removed from the pattern

website/src/pages/technical-manual/internals.mdx

@@ -126,13 +126,9 @@ These functions are more low level, probably not needed by the live coder.
 
 <JsDoc client:idle name="Pattern#stripContext" h={0} />
 
-## withLocation
+## withLoc
 
-<JsDoc client:idle name="Pattern#withLocation" h={0} />
+<JsDoc client:idle name="Pattern#withLoc" h={0} />
-
-## withMiniLocation
-
-<JsDoc client:idle name="Pattern#withMiniLocation" h={0} />
 
 ## filterHaps
 

website/src/pages/technical-manual/repl.mdx

@@ -32,19 +32,17 @@ In the JavaScript world, using transpilation is a common practise to be able to
 
 In the same tradition, Strudel can add a transpilation step to simplify the user code in the context of live coding. For example, the Strudel REPL lets the user create mini-notation patterns using just double quoted strings, while single quoted strings remain what they are:
 
-```js
+```strudel
-'c3 [e3 g3]*2';
+note("c3 [e3 g3]*2")
 ```
 
 is transpiled to:
 
-```js
+```strudel
-mini('c3 [e3 g3]*2').withMiniLocation([1, 0, 0], [1, 14, 14]);
+note(m('c3 [e3 g3]', 5))
 ```
 
-Here, the string is wrapped in `mini`, which will create a pattern from a mini-notation string. Additionally, the `withMiniLocation` method passes the original source code location of the string to the pattern, which enables highlighting active events.
+Here, the string is wrapped in `m`, which will create a pattern from a mini-notation string. As the second parameter, it gets passed source code location of the string, which enables highlighting active events later.
-
-Other convenient features like pseudo variables, operator overloading and top level await are possible with transpilation.
 
 After the transpilation, the code is ready to be evaluated into a `Pattern`.
 
@@ -56,16 +54,22 @@ While the transpilation allows JavaScript to express Patterns in a less verbose
 
 The mini-notation parser is implemented using `peggy`, which allows generating performant parsers for Domain Specific Languages (DSLs) using a concise grammar notation. The generated parser turns the mini-notation string into an AST which is used to call the respective Strudel functions with the given structure. For example, `"c3 [e3 g3]*2"` will result in the following calls:
 
-```js
+```strudel
 seq(
-  reify('c3').withLocation([1, 1, 1], [1, 4, 4]),
+  reify('c3').withLoc(6, 9),
-  seq(reify('e3').withLocation([1, 5, 5], [1, 8, 8]), reify('g3').withLocation([1, 8, 8], [1, 10, 10])).fast(2),
+  seq(reify('e3').withLoc(10, 12), reify('g3',).withLoc(13, 15))
-);
+)
 ```
 
 ### Highlighting Locations
 
-As seen in the examples above, both the JS and the mini-notation parser add source code locations using `withMiniLocation` and `withLocation` methods. While the JS parser adds locations relative to the user code as a whole, the mini-notation adds locations relative to the position of the mini-notation string. The absolute location of elements within mini-notation can be calculated by simply adding both locations together. This absolute location can be used to highlight active events in real time.
+As seen in the examples above, both the mini-notation parser adds the source code locations using `withLoc`.
+This location is calculated inside the `m` function, as the sum of 2 locations:
+
+1. the location where the mini notation string begins, as obtained from the JS parser
+2. the location of the substring inside the mini notation, as obtained from the mini notation parser
+
+The sum of both is passed to `withLoc` to tell each element its location, which can be later used for highlighting when it's active.
 
 ### Mini Notation