@astrojs/compiler 1.4.1 → 1.5.0

package/browser/index.d.ts

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

package/browser/index.js

@@ -1,67 +0,0 @@
-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);
-};
-export const convertToTSX = (input, options) => {
-    return ensureServiceIsRunning().convertToTSX(input, options);
-};
-let initializePromise;
-let longLivedService;
-export const teardown = () => {
-    initializePromise = undefined;
-    longLivedService = undefined;
-    globalThis['@astrojs/compiler'] = undefined;
-};
-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 || {}))),
-        convertToTSX: (input, options) => new Promise((resolve) => resolve(service.convertToTSX(input, options || {}))).then((result) => ({
-            ...result,
-            map: JSON.parse(result.map),
-        })),
-        parse: (input, options) => new Promise((resolve) => resolve(service.parse(input, options || {}))).then((result) => ({ ...result, ast: JSON.parse(result.ast) })),
-    };
-};

package/browser/utils.js

@@ -1,116 +0,0 @@
-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;
-}