prettier-plugin-embed 0.5.1 → 0.7.0

package/dist/embedded/solidity/options.d.ts

@@ -0,0 +1,58 @@
+import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
+declare const DEFAULT_COMMENTS_OR_TAGS: readonly ["solidity", "sol"];
+type CommentsOrTags = AutocompleteStringList<(typeof DEFAULT_COMMENTS_OR_TAGS)[number]>;
+type Defaults = StringListToInterfaceKey<typeof DEFAULT_COMMENTS_OR_TAGS>;
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedSolidityComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedSolidityTags";
+declare const EMBEDDED_LANGUAGE_PARSER: "embeddedSolidityParser";
+export declare const options: {
+    readonly embeddedSolidityComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: ["solidity", "sol"];
+        }];
+        readonly description: "Block comments that identify embedded Solidity in template literals. Requires the `prettier-plugin-solidity` plugin.";
+    };
+    readonly embeddedSolidityTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: ["solidity", "sol"];
+        }];
+        readonly description: "Tags that identify embedded Solidity in template literals. Requires the `prettier-plugin-solidity` plugin.";
+    };
+    readonly embeddedSolidityParser: {
+        readonly category: "Embed";
+        readonly type: "choice";
+        readonly default: "slang";
+        readonly description: "The parser used to format embedded Solidity.";
+        readonly choices: [{
+            readonly value: "slang";
+            readonly description: "Use the `slang` parser.";
+        }, {
+            readonly value: "antlr";
+            readonly description: "Use the `antlr` parser.";
+        }, {
+            readonly value: "solidity-parse";
+            readonly description: "Use the `solidity-parse` parser.";
+        }];
+    };
+};
+type Options = typeof options;
+declare module "../types.js" {
+    interface EmbeddedOptions extends Options {
+    }
+    interface EmbeddedDefaultCommentsHolder extends Defaults {
+    }
+    interface EmbeddedDefaultTagsHolder extends Defaults {
+    }
+    interface PluginEmbedOptions {
+        [EMBEDDED_LANGUAGE_COMMENTS]?: CommentsOrTags;
+        [EMBEDDED_LANGUAGE_TAGS]?: CommentsOrTags;
+        [EMBEDDED_LANGUAGE_PARSER]?: "slang" | "antlr" | "solidity-parse";
+    }
+}
+export {};

package/dist/embedded/sql/options.d.ts

@@ -59,7 +59,7 @@ export declare const options: {
         default: "sqlite";
         description: string;
         choices: {
-            value: "sqlite" | "bigquery" | "mysql" | "mariadb" | "postgresql";
+            value: "bigquery" | "mariadb" | "mysql" | "postgresql" | "sqlite";
             description: string;
         }[];
     };

package/dist/embedded/svelte/embedder.d.ts

@@ -0,0 +1,7 @@
+import { language } from "./language.js";
+export declare const embedder: import("../../types.js").Embedder;
+declare module "../types.js" {
+    interface EmbeddedEmbedders {
+        [language]: typeof embedder;
+    }
+}

package/dist/embedded/svelte/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./embedder.js";
+export * from "./language.js";
+export * from "./options.js";

package/dist/embedded/svelte/language.d.ts

@@ -0,0 +1,6 @@
+export declare const language = "embeddedSvelte";
+declare module "../types.js" {
+    interface EmbeddedLanguagesHolder {
+        [language]: undefined;
+    }
+}

package/dist/embedded/svelte/options.d.ts

@@ -0,0 +1,40 @@
+import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
+declare const DEFAULT_COMMENTS_OR_TAGS: readonly ["svelte"];
+type CommentsOrTags = AutocompleteStringList<(typeof DEFAULT_COMMENTS_OR_TAGS)[number]>;
+type Defaults = StringListToInterfaceKey<typeof DEFAULT_COMMENTS_OR_TAGS>;
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedSvelteComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedSvelteTags";
+export declare const options: {
+    readonly embeddedSvelteComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: ["svelte"];
+        }];
+        readonly description: "Block comments that identify embedded Svelte in template literals. Requires the `prettier-plugin-svelte` plugin.";
+    };
+    readonly embeddedSvelteTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: ["svelte"];
+        }];
+        readonly description: "Tags that identify embedded Svelte in template literals. Requires the `prettier-plugin-svelte` plugin.";
+    };
+};
+type Options = typeof options;
+declare module "../types.js" {
+    interface EmbeddedOptions extends Options {
+    }
+    interface EmbeddedDefaultCommentsHolder extends Defaults {
+    }
+    interface EmbeddedDefaultTagsHolder extends Defaults {
+    }
+    interface PluginEmbedOptions {
+        [EMBEDDED_LANGUAGE_COMMENTS]?: CommentsOrTags;
+        [EMBEDDED_LANGUAGE_TAGS]?: CommentsOrTags;
+    }
+}
+export {};

package/dist/embedded/toml/embedder.d.ts

@@ -1,10 +1,5 @@
-import type { Options } from "prettier";
-import type { Embedder } from "../../types.js";
 import { language } from "./language.js";
-export declare const embedder: Embedder<Options>;
-/**
- * Register the embedder to the EmbeddedEmbedders
- */
+export declare const embedder: import("../../types.js").Embedder;
 declare module "../types.js" {
     interface EmbeddedEmbedders {
         [language]: typeof embedder;

package/dist/embedded/toml/plugin-toml-types.d.ts

@@ -1,4 +1,4 @@
-import type { PrettierTaploOptions } from "prettier-plugin-toml";
+import type { PrettierOptions } from "prettier-plugin-toml";
 import type { NormalizeOptions } from "../utils.js";
-export interface PluginTomlOptions extends NormalizeOptions<PrettierTaploOptions> {
+export interface PluginTomlOptions extends NormalizeOptions<PrettierOptions> {
 }

package/dist/embedded/ts/embedder.d.ts

@@ -1,10 +1,5 @@
-import type { Options } from "prettier";
-import type { Embedder } from "../../types.js";
 import { language } from "./language.js";
-export declare const embedder: Embedder<Options>;
-/**
- * Register the embedder to the EmbeddedEmbedders
- */
+export declare const embedder: import("../../types.js").Embedder;
 declare module "../types.js" {
     interface EmbeddedEmbedders {
         [language]: typeof embedder;

package/dist/embedded/ts/options.d.ts

@@ -46,7 +46,7 @@ export declare const options: {
         default: "typescript";
         description: string;
         choices: {
-            value: "typescript" | "babel-ts";
+            value: "babel-ts" | "typescript";
             description: string;
         }[];
     };

package/dist/embedded/types.d.ts

@@ -1,5 +1,5 @@
 import type { Options, Parser, SupportOption } from "prettier";
-import type { LiteralUnion } from "type-fest";
+import type { LiteralUnion } from "../type-utils.js";
 import type { Embedder } from "../types.js";
 import type { Satisfies } from "./utils.js";
 type EmbeddedLanguageNamingConvention = `embedded${Capitalize<string>}`;

package/dist/embedded/utils.d.ts

@@ -1,12 +1,21 @@
 import type { Comment, Expression, TemplateLiteral } from "estree";
 import type { AstPath, Doc, Options } from "prettier";
 import { builders } from "prettier/doc";
-import type { LiteralUnion, OmitIndexSignature, UnionToIntersection } from "type-fest";
+import type { LiteralUnion, OmitIndexSignature, UnionToIntersection } from "../type-utils.js";
 import type { InternalPrintFun } from "../types.js";
+export declare function prepareTemplate(node: TemplateLiteral, createPlaceholder: (index: number) => string): {
+    trimmedText: string;
+    leadingWhitespaces: string;
+    trailingWhitespaces: string;
+};
+export declare function wrapEmbeddedDoc(contentDoc: Doc, options: {
+    preserveEmbeddedExteriorWhitespaces?: string[];
+    noEmbeddedMultiLineIndentation?: string[];
+}, commentOrTag: string, leadingWhitespaces: string, trailingWhitespaces: string, preserveExteriorWhitespaces?: boolean): Doc;
 export declare function printTemplateExpression(path: AstPath<Expression & {
     comments?: Comment[];
-}>, print: InternalPrintFun, templateLiteral: TemplateLiteral, index: number, tabWidth: number): builders.Group;
-export declare function printTemplateExpressions(path: AstPath<TemplateLiteral>, print: InternalPrintFun, options?: Options): builders.Group[];
+}>, print: InternalPrintFun, templateLiteral: TemplateLiteral, index: number, tabWidth: number, preserveIndentation?: boolean): builders.Group;
+export declare function printTemplateExpressions(path: AstPath<TemplateLiteral>, print: InternalPrintFun, options?: Options, preserveIndentation?: boolean): builders.Group[];
 export declare function simpleRehydrateDoc(doc: Doc, placeholderRegex: RegExp, expressionDocs: Doc[], 
 /**
  * How to handle newlines in the formatted content:
@@ -14,7 +23,7 @@ export declare function simpleRehydrateDoc(doc: Doc, placeholderRegex: RegExp, e
  * - "hardline": replace newlines with hardline (adds indentation)
  * - "literalline": replace newlines with literalline via replaceEndOfLine (preserves original indentation)
  */
-newlineHandling?: false | "hardline" | "literalline"): builders.Doc[] | builders.DocCommand;
+newlineHandling?: false | "hardline" | "literalline", lineBreakBeforeExpressions?: ReadonlySet<number>, interpolationTabWidth?: number, escapeClosingScript?: boolean): builders.Doc[] | builders.DocCommand;
 export declare function insertLanguage(languages: string[], language: string, firstLanguage: string): void;
 export declare const randomUUID: () => string;
 export declare function preparePlaceholder(leading?: string, trailing?: string): {

package/dist/embedded/xml/parser.d.ts

@@ -1,8 +1,10 @@
-// @ts-nocheck
-import type { Parser } from "prettier";
+import type { Parser, ParserOptions } from "prettier";
 import { language } from "./language.js";
-type SimplifiedNode = Record<string, unknown>;
-export declare const parser: Parser<SimplifiedNode>;
+type XmlNode = Record<string, unknown>;
+export declare function parseWithXmlPlugin(text: string, options: ParserOptions<XmlNode>, xmlParser: Parser<XmlNode>): Promise<XmlNode>;
+export declare function loadXmlParser(filepath?: string, loadDirectly?: () => Promise<unknown>, moduleUrl?: string | URL): Promise<Parser<XmlNode>>;
+export declare function parseXml(text: string, options: ParserOptions<XmlNode>, loadParser?: (filepath?: string) => Promise<Parser<XmlNode>>): Promise<XmlNode>;
+export declare const parser: Parser<XmlNode>;
 declare module "../types.js" {
     interface EmbeddedParsers {
         [language]: Parser;

package/dist/embedded/xquery/embedder.d.ts

@@ -0,0 +1,7 @@
+import { language } from "./language.js";
+export declare const embedder: import("../../types.js").Embedder;
+declare module "../types.js" {
+    interface EmbeddedEmbedders {
+        [language]: typeof embedder;
+    }
+}

package/dist/embedded/xquery/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./embedder.js";
+export * from "./language.js";
+export * from "./options.js";

package/dist/embedded/xquery/language.d.ts

@@ -0,0 +1,6 @@
+export declare const language = "embeddedXQuery";
+declare module "../types.js" {
+    interface EmbeddedLanguagesHolder {
+        [language]: undefined;
+    }
+}

package/dist/embedded/xquery/options.d.ts

@@ -0,0 +1,55 @@
+import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
+declare const DEFAULT_COMMENTS_OR_TAGS: readonly ["xquery", "xq"];
+type CommentsOrTags = AutocompleteStringList<(typeof DEFAULT_COMMENTS_OR_TAGS)[number]>;
+type Defaults = StringListToInterfaceKey<typeof DEFAULT_COMMENTS_OR_TAGS>;
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedXQueryComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedXQueryTags";
+declare const EMBEDDED_LANGUAGE_PARSER: "embeddedXQueryParser";
+export declare const options: {
+    readonly embeddedXQueryComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: ["xquery", "xq"];
+        }];
+        readonly description: "Block comments that identify embedded XQuery in template literals. Requires the `prettier-plugin-xquery` plugin.";
+    };
+    readonly embeddedXQueryTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: ["xquery", "xq"];
+        }];
+        readonly description: "Tags that identify embedded XQuery in template literals. Requires the `prettier-plugin-xquery` plugin.";
+    };
+    readonly embeddedXQueryParser: {
+        readonly category: "Embed";
+        readonly type: "choice";
+        readonly default: "xquery";
+        readonly description: "The parser used to format embedded XQuery.";
+        readonly choices: [{
+            readonly value: "xquery";
+            readonly description: "Use the `xquery` parser.";
+        }, {
+            readonly value: "xquery4";
+            readonly description: "Use the `xquery4` parser.";
+        }];
+    };
+};
+type Options = typeof options;
+declare module "../types.js" {
+    interface EmbeddedOptions extends Options {
+    }
+    interface EmbeddedDefaultCommentsHolder extends Defaults {
+    }
+    interface EmbeddedDefaultTagsHolder extends Defaults {
+    }
+    interface PluginEmbedOptions {
+        [EMBEDDED_LANGUAGE_COMMENTS]?: CommentsOrTags;
+        [EMBEDDED_LANGUAGE_TAGS]?: CommentsOrTags;
+        [EMBEDDED_LANGUAGE_PARSER]?: "xquery" | "xquery4";
+    }
+}
+export {};

package/dist/import-module-worker.js

@@ -0,0 +1,45 @@
+import { pathToFileURL as e } from "node:url";
+import { parentPort as t, workerData as n } from "node:worker_threads";
+//#region scripts/import-module-worker.ts
+async function r(e) {
+	try {
+		return await import(e.href);
+	} catch (t) {
+		if (!(t instanceof Error) || !("code" in t) || ![
+			"ERR_UNKNOWN_FILE_EXTENSION",
+			"ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX",
+			"ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING"
+		].includes(String(t.code))) throw t;
+		let { register: n } = await import("node:module");
+		if (!n) throw t;
+		n(`data:text/javascript,${encodeURIComponent(`
+        export function resolve(specifier, context, nextResolve) {
+          return nextResolve(specifier, {
+            ...context,
+            parentURL: context.parentURL === ${JSON.stringify(import.meta.url)}
+              ? ${JSON.stringify(e.href)}
+              : context.parentURL,
+          });
+        }
+      `)}`);
+		let r;
+		try {
+			r = await Promise.all(["tsx/cjs/api", "tsx/esm/api"].map((e) => import.meta.resolve(e)));
+		} catch {
+			throw t;
+		}
+		let [i, a] = await Promise.all(r.map((e) => import(e)));
+		return i.register(), a.register({ namespace: "prettier-plugin-embed" }).import(e.href, e.href);
+	}
+}
+(async ({ absolutePath: n }) => {
+	try {
+		let i = await r(e(n));
+		t?.postMessage({ overrides: i.embeddedOverrides ?? i.default });
+	} catch (e) {
+		t?.postMessage({ error: e instanceof Error ? e : Error(String(e)) });
+	} finally {
+		t?.close();
+	}
+})(n);
+//#endregion