@astrojs/compiler 0.16.0 → 0.17.0-pre.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @astrojs/compiler
 
+## 0.16.1
+
+### Patch Changes
+
+- 9fcc43b: Build JS during the release
+
 ## 0.16.0
 
 ### Minor Changes

package/browser/index.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,55 @@
+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 = async (options) => {
+    let wasmURL = options.wasmURL;
+    if (!wasmURL)
+        throw new Error('Must provide the "wasmURL" option');
+    wasmURL += '';
+    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 (!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');
+    return longLivedService;
+};
+const instantiateWASM = async (wasmURL, importObject) => {
+    let response = undefined;
+    if (WebAssembly.instantiateStreaming) {
+        response = await WebAssembly.instantiateStreaming(fetch(wasmURL), importObject);
+    }
+    else {
+        const fetchAndInstantiateTask = async () => {
+            const wasmArrayBuffer = await fetch(wasmURL).then((res) => res.arrayBuffer());
+            return WebAssembly.instantiate(wasmArrayBuffer, importObject);
+        };
+        response = await fetchAndInstantiateTask();
+    }
+    return response;
+};
+const startRunningService = async (wasmURL) => {
+    const go = new Go();
+    const wasm = await instantiateWASM(wasmURL, go.importObject);
+    go.run(wasm.instance);
+    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/utils.d.ts

@@ -0,0 +1,25 @@
+import { Node, ParentNode, RootNode, LiteralNode, ElementNode, CustomElementNode, ComponentNode, FragmentNode, TagLikeNode, ExpressionNode, TextNode, CommentNode, DoctypeNode, FrontmatterNode } from '../shared/ast';
+export interface Visitor {
+    (node: Node, parent?: ParentNode, index?: number): void | Promise<void>;
+}
+export declare const is: {
+    parent(node: Node): node is ParentNode;
+    literal(node: Node): node is LiteralNode;
+    tag(node: Node): node is TagLikeNode;
+    whitespace(node: Node): node is TextNode;
+    root: (node: Node) => node is RootNode;
+    element: (node: Node) => node is ElementNode;
+    customElement: (node: Node) => node is CustomElementNode;
+    component: (node: Node) => node is ComponentNode;
+    fragment: (node: Node) => node is FragmentNode;
+    expression: (node: Node) => node is ExpressionNode;
+    text: (node: Node) => node is TextNode;
+    doctype: (node: Node) => node is DoctypeNode;
+    comment: (node: Node) => node is CommentNode;
+    frontmatter: (node: Node) => node is FrontmatterNode;
+};
+export declare function walk(node: ParentNode, callback: Visitor): void;
+export interface SerializeOtions {
+    selfClose: boolean;
+}
+export declare function serialize(root: Node, opts?: SerializeOtions): string;

package/browser/utils.js

@@ -0,0 +1,116 @@
+function guard(type) {
+    return (node) => node.type === type;
+}
+export const is = {
+    parent(node) {
+        return Array.isArray(node.children);
+    },
+    literal(node) {
+        return typeof node.value === 'string';
+    },
+    tag(node) {
+        return node.type === 'element' || node.type === 'custom-element' || node.type === 'component' || node.type === 'fragment';
+    },
+    whitespace(node) {
+        return node.type === 'text' && node.value.trim().length === 0;
+    },
+    root: guard('root'),
+    element: guard('element'),
+    customElement: guard('custom-element'),
+    component: guard('component'),
+    fragment: guard('fragment'),
+    expression: guard('expression'),
+    text: guard('text'),
+    doctype: guard('doctype'),
+    comment: guard('comment'),
+    frontmatter: guard('frontmatter'),
+};
+class Walker {
+    constructor(callback) {
+        this.callback = callback;
+    }
+    async visit(node, parent, index) {
+        await this.callback(node, parent, index);
+        if (is.parent(node)) {
+            let promises = [];
+            for (let i = 0; i < node.children.length; i++) {
+                const child = node.children[i];
+                promises.push(this.callback(child, node, i));
+            }
+            await Promise.all(promises);
+        }
+    }
+}
+export function walk(node, callback) {
+    const walker = new Walker(callback);
+    walker.visit(node);
+}
+function serializeAttributes(node) {
+    let output = '';
+    for (const attr of node.attributes) {
+        output += ' ';
+        switch (attr.kind) {
+            case 'empty': {
+                output += `${attr.name}`;
+                break;
+            }
+            case 'expression': {
+                output += `${attr.name}={${attr.value}}`;
+                break;
+            }
+            case 'quoted': {
+                output += `${attr.name}="${attr.value}"`;
+                break;
+            }
+            case 'template-literal': {
+                output += `${attr.name}=\`${attr.value}\``;
+                break;
+            }
+            case 'shorthand': {
+                output += `{${attr.name}}`;
+                break;
+            }
+            case 'spread': {
+                output += `{...${attr.value}}`;
+                break;
+            }
+        }
+    }
+    return output;
+}
+export function serialize(root, opts = { selfClose: true }) {
+    let output = '';
+    function visitor(node) {
+        if (is.root(node)) {
+            node.children.forEach((child) => visitor(child));
+        }
+        else if (is.frontmatter(node)) {
+            output += `---${node.value}---\n\n`;
+        }
+        else if (is.comment(node)) {
+            output += `<!--${node.value}-->`;
+        }
+        else if (is.expression(node)) {
+            output += `{`;
+            node.children.forEach((child) => visitor(child));
+            output += `}`;
+        }
+        else if (is.literal(node)) {
+            output += node.value;
+        }
+        else if (is.tag(node)) {
+            output += `<${node.name}`;
+            output += serializeAttributes(node);
+            if (node.children.length == 0 && opts.selfClose) {
+                output += ` />`;
+            }
+            else {
+                output += '>';
+                node.children.forEach((child) => visitor(child));
+                output += `</${node.name}>`;
+            }
+        }
+    }
+    visitor(root);
+    return output;
+}

package/browser/wasm_exec.d.ts

@@ -0,0 +1,35 @@
+export default class Go {
+    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;
+    private _makeFuncWrapper;
+}