@astrojs/compiler 0.0.0-sourcemap-20230103195910 → 0.0.0-sync-20230409173822

package/CHANGELOG.md

@@ -1,10 +1,119 @@
 # @astrojs/compiler
 
-## 0.0.0-sourcemap-20230103195910
+## 0.0.0-sync-20230409173822
 
 ### Patch Changes
 
-- ca1806c: Fixes export hoisting edge case
+- 5803b39: Add a sync entrypoint
+
+## 1.3.1
+
+### Patch Changes
+
+- e0baa85: Preserve whitespace in slots
+
+## 1.3.0
+
+### Minor Changes
+
+- 95a6610: Expose the `convertToTSX` function in the compiler browser bundle
+- 6d168dd: Add ContainsHead flag for metadata
+
+## 1.2.2
+
+### Patch Changes
+
+- a8a845f: Fix regression related to self-closing tags
+
+## 1.2.1
+
+### Patch Changes
+
+- 348840b: Fix getStaticPaths export when used with a TypeScript type ([#4929](https://github.com/withastro/astro/issues/4929))
+- 8ed067e: Fix parse error for multiline `export type` using Unions or Intersections
+- 6354e50: Improve handling of self-closing tags returned from expression
+- 5a5f91d: Fix `define:vars` when used with a `style` attribute
+- b637e9a: Fix ignored `form` elements after a `form` element that contains an expression
+- 2658ed4: Correctly apply style when `class` and `class:list` are both used
+
+## 1.2.0
+
+### Minor Changes
+
+- b2cfd00: Add teardown API to remove WASM instance after using the compiler
+
+## 1.1.2
+
+### Patch Changes
+
+- 2de6128: Preserve namespaced attributes when using expressions
+- af13f2d: Fix incorrect `convertToTSX` types. The function accepts `filename`, not `sourcefile`.
+- 5eb4fff: Compile `set:html` and `set:text` quoted and template literal attributes as strings
+
+## 1.1.1
+
+### Patch Changes
+
+- 6765f01: Fix attributes starting with : not being properly transformed in the TSX output
+
+## 1.1.0
+
+### Minor Changes
+
+- a75824d: Allow passing through result to slot call
+
+## 1.0.2
+
+### Patch Changes
+
+- 0c27f3f: Collapse multiple trailing text nodes if present
+
+## 1.0.1
+
+### Patch Changes
+
+- 94b2c02: Prevent insertion of maybeRenderHead on hoisted scripts
+
+## 1.0.0
+
+### Major Changes
+
+- 8e86bc6: The Astro compiler is officially stable! This release is entirely ceremonial, the code is the same as [`@astrojs/compiler@0.33.0`](https://github.com/withastro/compiler/releases/tag/%40astrojs%2Fcompiler%400.33.0)
+
+## 0.33.0
+
+### Minor Changes
+
+- 1adac72: Improve error recovery when using the `transform` function. The compiler will now properly reject the promise with a useful message and stacktrace rather than print internal errors to stdout.
+
+### Patch Changes
+
+- 68d3c0c: Fix edge case where `export type` could hang the compiler
+- ec1ddf0: Handle edge case with TypeScript generics handling and our TSX output
+- 23d1fc0: Ignore trailing whitespace in components
+
+## 0.32.0
+
+### Minor Changes
+
+- 2404848: Remove `pathname` option in favour of `sourcefile` option
+- 2ca86f6: Remove `site` and `projectRoot` options in favour of the `astroGlobalArgs` option
+- edd3e0e: Merge `sourcefile` and `moduleId` options as a single `filename` option. Add a new `normalizedFilename` option to generate stable hashes instead.
+- 08843bd: Remove `experimentalStaticExtraction` option. It is now the default.
+
+## 0.31.4
+
+### Patch Changes
+
+- 960b853: Rename `SerializeOtions` interface to `SerializeOptions`
+- fcab891: Fixes export hoisting edge case
+- 47de01a: Handle module IDs containing quotes
+
+## 0.31.3
+
+### Patch Changes
+
+- fd5cb57: Rollback https://github.com/withastro/compiler/pull/674
 
 ## 0.31.2
 
@@ -66,7 +175,7 @@
 
 ### Patch Changes
 
-- ec745f4: Self-closing tags will now retreive "end" positional data
+- ec745f4: Self-closing tags will now retrieve "end" positional data
 - a6c2822: Fix a few TSX output errors
 
 ## 0.29.15
@@ -164,7 +273,7 @@
 
 ### Minor Changes
 
-- fd2fc28: Fix some utf8 compatability issues
+- fd2fc28: Fix some utf8 compatibility issues
 
 ### Patch Changes
 
@@ -344,7 +453,7 @@
 
 - a28c3d8: Fix handling of unbalanced quotes in expression attributes
 - 28d1d4d: Fix handling of TS generics inside of expressions
-- 356d3b6: Prevent wraping module scripts with scope
+- 356d3b6: Prevent wrapping module scripts with scope
 
 ## 0.22.1
 

package/README.md

@@ -23,8 +23,7 @@ The Astro compiler can convert `.astro` syntax to a TypeScript Module whose defa
 import { transform } from '@astrojs/compiler';
 
 const result = await transform(source, {
-  site: 'https://mysite.dev',
-  sourcefile: '/Users/astro/Code/project/src/pages/index.astro',
+  filename: '/Users/astro/Code/project/src/pages/index.astro',
   sourcemap: 'both',
   internalURL: 'astro/runtime/server/index.js',
 });

package/browser/index.d.ts

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

@@ -5,8 +5,16 @@ export const 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)
@@ -50,6 +58,10 @@ const startRunningService = async (wasmURL) => {
     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.d.ts

@@ -19,7 +19,9 @@ export declare const is: {
     frontmatter: (node: Node) => node is FrontmatterNode;
 };
 export declare function walk(node: ParentNode, callback: Visitor): void;
-export interface SerializeOtions {
+export interface SerializeOptions {
     selfClose: boolean;
 }
-export declare function serialize(root: Node, opts?: SerializeOtions): string;
+/** @deprecated Please use `SerializeOptions`  */
+export type SerializeOtions = SerializeOptions;
+export declare function serialize(root: Node, opts?: SerializeOptions): string;

package/node/index.d.ts

@@ -1,6 +1,7 @@
-export type { PreprocessorResult, ParseOptions, TransformOptions, HoistedScript, TransformResult, ParseResult } from '../shared/types';
+export type { HoistedScript, ParseOptions, ParseResult, PreprocessorResult, TransformOptions, TransformResult } from '../shared/types';
 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 compile: (template: string) => Promise<string>;
+export declare const teardown: typeof types.teardown;

package/node/index.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs';
-import Go from './wasm_exec.js';
 import { fileURLToPath } from 'url';
+import Go from './wasm_exec.js';
 export const transform = async (input, options) => {
     return getService().then((service) => service.transform(input, options));
 };
@@ -15,6 +15,10 @@ export const compile = async (template) => {
     return mod;
 };
 let longLivedService;
+export const teardown = () => {
+    longLivedService = undefined;
+    globalThis['@astrojs/compiler'] = undefined;
+};
 let getService = () => {
     if (!longLivedService) {
         longLivedService = startRunningService().catch((err) => {

package/node/sync.d.ts

@@ -0,0 +1,5 @@
+import type * as types from '../shared/types';
+export declare const transform: (input: string, options: types.TransformOptions | undefined) => types.TransformResult;
+export declare const parse: (input: string, options: types.ParseOptions | undefined) => types.ParseResult;
+export declare const convertToTSX: (input: string, options: types.ConvertToTSXOptions | undefined) => types.TSXResult;
+export declare function startRunningService(wasmPath: string): Promise<string>;

package/node/sync.js

@@ -0,0 +1,52 @@
+import { promises as fs } from 'fs';
+import Go from './wasm_exec';
+function getService() {
+    if (!longLivedService) {
+        throw new Error("Service hasn't been started. Start it with startRunningService.");
+    }
+    return longLivedService;
+}
+let longLivedService;
+export const transform = ((input, options) => getService().transform(input, options));
+export const parse = ((input, options) => {
+    return getService().parse(input, options);
+});
+export const convertToTSX = ((input, options) => {
+    return getService().convertToTSX(input, options);
+});
+export async function startRunningService(wasmPath) {
+    const go = new Go();
+    const wasm = await instantiateWASM(wasmPath, go.importObject);
+    go.run(wasm.instance);
+    const _service = globalThis['@astrojs/compiler'];
+    longLivedService = {
+        transform: (input, options) => {
+            try {
+                return _service.transform(input, options || {});
+            }
+            catch (err) {
+                // Recreate the service next time on panic
+                longLivedService = void 0;
+                throw err;
+            }
+        },
+        parse: (input, options) => {
+            const result = _service.parse(input, options || {});
+            return { ...result, ast: JSON.parse(result.ast) };
+        },
+        convertToTSX: (input, options) => {
+            const result = _service.convertToTSX(input, options || {});
+            return { ...result, map: JSON.parse(result.map) };
+        },
+    };
+    return 'hey';
+}
+async function instantiateWASM(wasmURL, importObject) {
+    let response = undefined;
+    const fetchAndInstantiateTask = async () => {
+        const wasmArrayBuffer = await fs.readFile(wasmURL).then((res) => res.buffer);
+        return WebAssembly.instantiate(new Uint8Array(wasmArrayBuffer), importObject);
+    };
+    response = await fetchAndInstantiateTask();
+    return response;
+}

package/node/utils.d.ts

@@ -19,7 +19,9 @@ export declare const is: {
     frontmatter: (node: Node) => node is FrontmatterNode;
 };
 export declare function walk(node: ParentNode, callback: Visitor): void;
-export interface SerializeOtions {
+export interface SerializeOptions {
     selfClose: boolean;
 }
-export declare function serialize(root: Node, opts?: SerializeOtions): string;
+/** @deprecated Please use `SerializeOptions`  */
+export type SerializeOtions = SerializeOptions;
+export declare function serialize(root: Node, opts?: SerializeOptions): string;

package/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "bugs": "https://github.com/withastro/compiler/issues",
   "homepage": "https://astro.build",
-  "version": "0.0.0-sourcemap-20230103195910",
+  "version": "0.0.0-sync-20230409173822",
   "main": "./node/index.js",
   "types": "./node",
   "repository": {
@@ -18,6 +18,10 @@
       "import": "./node/index.js",
       "default": "./browser/index.js"
     },
+    "./sync": {
+      "import": "./node/sync.js",
+      "default": "./node/sync.js"
+    },
     "./utils": {
       "browser": "./browser/utils.js",
       "import": "./node/utils.js",
@@ -28,10 +32,10 @@
   },
   "devDependencies": {
     "@jridgewell/trace-mapping": "^0.3.16",
-    "@types/node": "^16.11.64",
+    "@types/node": "^18.15.11",
     "@types/sass": "^1.43.1",
     "acorn": "^8.8.1",
-    "typescript": "~4.8.4"
+    "typescript": "~4.9.0"
   },
   "scripts": {
     "build": "tsc -p ."

package/shared/ast.d.ts

@@ -1,6 +1,6 @@
-export declare type ParentNode = RootNode | ElementNode | ComponentNode | CustomElementNode | FragmentNode | ExpressionNode;
-export declare type LiteralNode = TextNode | DoctypeNode | CommentNode | FrontmatterNode;
-export declare type Node = RootNode | ElementNode | ComponentNode | CustomElementNode | FragmentNode | ExpressionNode | TextNode | FrontmatterNode | DoctypeNode | CommentNode;
+export type ParentNode = RootNode | ElementNode | ComponentNode | CustomElementNode | FragmentNode | ExpressionNode;
+export type LiteralNode = TextNode | DoctypeNode | CommentNode | FrontmatterNode;
+export type Node = RootNode | ElementNode | ComponentNode | CustomElementNode | FragmentNode | ExpressionNode | TextNode | FrontmatterNode | DoctypeNode | CommentNode;
 export interface Position {
     start: Point;
     end?: Point;
@@ -56,7 +56,7 @@ export interface CustomElementNode extends ParentLikeNode {
     name: string;
     attributes: AttributeNode[];
 }
-export declare type TagLikeNode = ElementNode | FragmentNode | ComponentNode | CustomElementNode;
+export type TagLikeNode = ElementNode | FragmentNode | ComponentNode | CustomElementNode;
 export interface DoctypeNode extends ValueNode {
     type: 'doctype';
 }

package/shared/types.d.ts

@@ -33,22 +33,21 @@ export interface DiagnosticLocation {
 }
 export interface TransformOptions {
     internalURL?: string;
-    site?: string;
-    sourcefile?: string;
-    pathname?: string;
-    moduleId?: string;
+    filename?: string;
+    normalizedFilename?: string;
     sourcemap?: boolean | 'inline' | 'external' | 'both';
+    astroGlobalArgs?: string;
     compact?: boolean;
+    resultScopedSlot?: boolean;
     /**
      * @deprecated "as" has been removed and no longer has any effect!
      */
     as?: 'document' | 'fragment';
-    projectRoot?: string;
     resolvePath?: (specifier: string) => Promise<string>;
     preprocessStyle?: (content: string, attrs: Record<string, string>) => null | Promise<PreprocessorResult | PreprocessorError>;
-    experimentalStaticExtraction?: boolean;
 }
-export declare type HoistedScript = {
+export type ConvertToTSXOptions = Pick<TransformOptions, 'filename' | 'normalizedFilename'>;
+export type HoistedScript = {
     type: string;
 } & ({
     type: 'external';
@@ -73,6 +72,7 @@ export interface TransformResult {
     scripts: HoistedScript[];
     hydratedComponents: HydratedComponent[];
     clientOnlyComponents: HydratedComponent[];
+    containsHead: boolean;
 }
 export interface SourceMap {
     file: string;
@@ -93,10 +93,19 @@ export interface ParseResult {
 }
 export declare function transform(input: string, options?: TransformOptions): Promise<TransformResult>;
 export declare function parse(input: string, options?: ParseOptions): Promise<ParseResult>;
-export declare function convertToTSX(input: string, options?: {
-    sourcefile?: string;
-}): Promise<TSXResult>;
+export declare function convertToTSX(input: string, options?: ConvertToTSXOptions): Promise<TSXResult>;
 export declare function initialize(options: InitializeOptions): Promise<void>;
+/**
+ * When calling the core compiler APIs, e.g. `transform`, `parse`, etc, they
+ * would automatically instantiate a WASM instance to process the input. When
+ * done, you can call this to manually teardown the WASM instance.
+ *
+ * If the APIs are called again, they will automatically instantiate a new WASM
+ * instance. In browsers, you have to call `initialize()` again before using the APIs.
+ *
+ * Note: Calling teardown is optional and exists mostly as an optimization only.
+ */
+export declare function teardown(): void;
 export interface InitializeOptions {
     wasmURL?: string;
 }

package/sync.d.ts

@@ -0,0 +1 @@
+export * from './node/sync';