@astrojs/compiler 0.11.0-next.0 → 0.11.3

package/CHANGELOG.md

@@ -1,13 +1,48 @@
 # @astrojs/compiler
 
-## 0.11.0-next.0
+## 0.11.3
+
+### Patch Changes
+
+- dcf15bf: Fixes bug causing a crash when using Astro.resolve on a hoisted script
+
+## 0.11.2
+
+### Patch Changes
+
+- 41cc6ef: Fix memory issue caused by duplicate WASM instantiations
+
+## 0.11.1
+
+### Patch Changes
+
+- 4039682: Fixes hoist script tracking when passed a variable
+
+## 0.11.0
+
+### Minor Changes
+
+- f5d4006: Switch from TinyGo to Go's built-in WASM output. While this is an unfortunate size increase for our `.wasm` file, it should also be significantly more stable and cut down on hard-to-reproduce bugs.
+
+  Please see https://github.com/withastro/compiler/pull/291 for more details.
+
+## 0.11.0-next--wasm.0
 
 ### Minor Changes
 
-- 083d604: Do not render implicit tags created during the parsing process
-- d188c74: Remove "as" option, treats all documents as fragments that generate no implicit tags
-- c4b6b05: Add `parse` function which generates an AST
-- d84c3a2: Adds support for `Astro.self` (as accepted in the [Recursive Components RFC](https://github.com/withastro/rfcs/blob/main/active-rfcs/0000-recursive-components.md)).
+- 9212ccc: Switch from TinyGo to Go's built-in WASM output. While this is an unfortunate size increase for our `WASM` file, it should also be significantly more stable and cut down on hard-to-reproduce bugs.
+
+  Please see https://github.com/withastro/compiler/pull/291 for more details.
+
+## 0.10.2
+
+### Patch Changes
+
+- 7f7c65c: Fix conditional rendering for special elements like `iframe` and `noscript`
+- 9d789c9: Fix handling of nested template literals inside of expressions
+- 5fa9e53: Fix handling of special characters inside of expressions
+- 8aaa956: Formalize support for magic `data-astro-raw` attribute with new, official `is:raw` directive
+- c698350: Improve MathML support. `{}` inside of `<math>` is now treated as raw text rather than an expression construct.
 
 ## 0.10.1
 

package/README.md

@@ -12,15 +12,7 @@ npm install @astrojs/compiler
 
 ## Usage
 
-_Note: Public APIs are likely to change before 1.0! Use at your own discretion._
-
-#### Transform `.astro` to valid TypeScript
-
-The Astro compiler can convert `.astro` syntax to a TypeScript Module whose default export generates HTML.
-
-**Some notes**...
-- TypeScript is valid `.astro` syntax! The output code may need an additional post-processing step to generate valid JavaScript.
-- `.astro` files rely on a server implementation exposed as `astro/internal` in the Node ecosystem. Other runtimes currently need to bring their own rendering implementation and reference it via `internalURL`. This is a pain point we're looking into fixing.
+_Note: API will change before 1.0! Use at your own discretion._
 
 ```js
 import { transform } from '@astrojs/compiler';
@@ -33,31 +25,6 @@ const result = await transform(source, {
 });
 ```
 
-#### Parse `.astro` and return an AST
-
-The Astro compiler can emit an AST using the `parse` method.
-
-**Some notes**...
-- Position data is currently incomplete and in some cases incorrect. We're working on it!
-- A `TextNode` can represent both HTML `text` and JavaScript/TypeScript source code.
-- The `@astrojs/compiler/utils` entrypoint exposes a `walk` function that can be used to traverse the AST. It also exposes the `is` helper which can be used as guards to derive the proper types for each `node`.
-
-```js
-import { parse } from '@astrojs/compiler';
-import { walk, is } from '@astrojs/compiler/utils';
-
-const result = await parse(source, {
-  position: false, // defaults to `true`
-});
-
-walk(result.ast, (node) => {
-  // `tag` nodes are `element` | `custom-element` | `component`
-  if (is.tag(node)) {
-    console.log(node.name);
-  }
-})
-```
-
 ## Contributing
 
 [CONTRIBUTING.md](./CONTRIBUTING.md)

package/browser/index.d.ts

@@ -1,4 +1,3 @@
 import type * as types from '../shared/types';
 export declare const transform: typeof types.transform;
-export declare const parse: typeof types.parse;
 export declare const initialize: typeof types.initialize;

package/browser/index.js

@@ -2,31 +2,29 @@ import Go from './wasm_exec.js';
 export const transform = (input, options) => {
     return ensureServiceIsRunning().transform(input, options);
 };
-export const parse = (input, options) => {
-    return ensureServiceIsRunning().parse(input, options);
-};
 let initializePromise;
 let longLivedService;
-export const initialize = (options) => {
+export const initialize = async (options) => {
     let wasmURL = options.wasmURL;
     if (!wasmURL)
         throw new Error('Must provide the "wasmURL" option');
     wasmURL += '';
-    if (initializePromise)
-        throw new Error('Cannot call "initialize" more than once');
-    initializePromise = startRunningService(wasmURL);
-    initializePromise.catch(() => {
-        // Let the caller try again if this fails
-        initializePromise = void 0;
-    });
-    return initializePromise;
+    if (!initializePromise) {
+        initializePromise = startRunningService(wasmURL).catch((err) => {
+            // Let the caller try again if this fails.
+            initializePromise = void 0;
+            // But still, throw the error back up the caller.
+            throw err;
+        });
+    }
+    longLivedService = longLivedService || (await initializePromise);
 };
 let ensureServiceIsRunning = () => {
-    if (longLivedService)
-        return longLivedService;
-    if (initializePromise)
+    if (!initializePromise)
+        throw new Error('You need to call "initialize" before calling this');
+    if (!longLivedService)
         throw new Error('You need to wait for the promise returned from "initialize" to be resolved before calling this');
-    throw new Error('You need to call "initialize" before calling this');
+    return longLivedService;
 };
 const instantiateWASM = async (wasmURL, importObject) => {
     let response = undefined;
@@ -46,15 +44,8 @@ const startRunningService = async (wasmURL) => {
     const go = new Go();
     const wasm = await instantiateWASM(wasmURL, go.importObject);
     go.run(wasm.instance);
-    const apiKeys = new Set(['transform', 'parse']);
-    const service = Object.create(null);
-    for (const key of apiKeys.values()) {
-        const globalKey = `__astro_${key}`;
-        service[key] = globalThis[globalKey];
-        delete globalThis[globalKey];
-    }
-    longLivedService = {
+    const service = globalThis['@astrojs/compiler'];
+    return {
         transform: (input, options) => new Promise((resolve) => resolve(service.transform(input, options || {}))),
-        parse: (input, options) => new Promise((resolve) => resolve(service.parse(input, options || {}))).then((result) => ({ ...result, ast: JSON.parse(result.ast) })),
     };
 };

package/browser/wasm_exec.d.ts

@@ -1,5 +1,33 @@
 export default class Go {
-    importObject: Record<string, any>;
+    importObject: {
+        go: {
+            'runtime.wasmExit': (sp: any) => void;
+            'runtime.wasmWrite': (sp: any) => void;
+            'runtime.resetMemoryDataView': (sp: any) => void;
+            'runtime.nanotime1': (sp: any) => void;
+            'runtime.walltime': (sp: any) => void;
+            'runtime.scheduleTimeoutEvent': (sp: any) => void;
+            'runtime.clearTimeoutEvent': (sp: any) => void;
+            'runtime.getRandomData': (sp: any) => void;
+            'syscall/js.finalizeRef': (sp: any) => void;
+            'syscall/js.stringVal': (sp: any) => void;
+            'syscall/js.valueGet': (sp: any) => void;
+            'syscall/js.valueSet': (sp: any) => void;
+            'syscall/js.valueDelete': (sp: any) => void;
+            'syscall/js.valueIndex': (sp: any) => void;
+            'syscall/js.valueSetIndex': (sp: any) => void;
+            'syscall/js.valueCall': (sp: any) => void;
+            'syscall/js.valueInvoke': (sp: any) => void;
+            'syscall/js.valueNew': (sp: any) => void;
+            'syscall/js.valueLength': (sp: any) => void;
+            'syscall/js.valuePrepareString': (sp: any) => void;
+            'syscall/js.valueLoadString': (sp: any) => void;
+            'syscall/js.valueInstanceOf': (sp: any) => void;
+            'syscall/js.copyBytesToGo': (sp: any) => void;
+            'syscall/js.copyBytesToJS': (sp: any) => void;
+            debug: (value: any) => void;
+        };
+    };
     constructor();
     run(instance: any): Promise<void>;
     private _resume;