@inlang/paraglide-js 1.0.0-prerelease.9 → 1.0.0

package/README.md

@@ -1,39 +1,90 @@
-<!-- ## ATTENTION: Paraglide is in pre-release mode. Discuss the API at https://github.com/inlang/monorepo/discussions/1464 -->
-<doc-links>
-    <doc-link title="ATTENTION: Paraglide is in pre-release mode." icon="mdi:github" href="https://github.com/inlang/monorepo/discussions/1464" description="Discuss the API on GitHub."></doc-link>
-</doc-links>
+<!-- ![Paraglide JS header image](https://cdn.jsdelivr.net/gh/inlang/monorepo@latest/inlang/source-code/paraglide/paraglide-js/assets/paraglide-js-header.png) -->
+
+[<img src="https://cdn.loom.com/sessions/thumbnails/a8365ec4fa2c4f6bbbf4370cf22dd7f6-with-play.gif" width="100%" /> Watch the pre-release demo of Paraglide JS](https://www.youtube.com/watch?v=-YES3CCAG90)
+
+Attention: The following features are missing and will be added in the upcoming weeks:
+
+- [ ] Support for pluralization
+
+# The i18n library that you can set up within 3 lines of code
+
+Type in the following command into your terminal to get started immediately:
+
+```bash
+npx @inlang/paraglide-js@latest init
+```
 
-<doc-gallery>TODO: adapter gallery</doc-gallery>
+# Features
+
+<doc-features>
+  <doc-feature title="No unused translations" image="https://cdn.jsdelivr.net/gh/inlang/monorepo@latest/inlang/source-code/paraglide/paraglide-js/assets/unused-translations.png"></doc-feature>
+  <doc-feature title="Reduced payload" image="https://cdn.jsdelivr.net/gh/inlang/monorepo@latest/inlang/source-code/paraglide/paraglide-js/assets/reduced-payload.png"></doc-feature>
+  <doc-feature title="Typesafety" image="https://cdn.jsdelivr.net/gh/inlang/monorepo@latest/inlang/source-code/paraglide/paraglide-js/assets/typesafe.png"></doc-feature>
+</doc-features>
+
+### Treeshaking
+
+<doc-figure src="https://cdn.jsdelivr.net/gh/inlang/monorepo@latest/inlang/source-code/paraglide/paraglide-js/assets/tree-shaking.jpg" alt="An illustration explaining the benefits of treeshaking in software" caption="How Paraglide JS treeshaking works">
+</doc-figure>
+
+Treeshaking gives us superpowers. With it, each page of your app only loads the messages that it actually uses. Incremental loading like this would usually take hours of manual tweaking to get right. With Paraglide-JS you get it for free. Say goodbye to huge bundles.
 
-- [x] the smallest, fastest, and most typesafe i18n library
-- [x] only bundles the messages that are used (tree-shaking)
-- [x] storage agnostic (JSON, YAML, CSV, etc.) 
-- [x] plug & play with the [inlang ecosystem](https://inlang.com/marketplace)
 
 # Getting started
 
-1. Run the following command in your terminal: 
+### 1. Initialize paraglide-js
+
+You can initialize paraglide-js by running the following command in your terminal:
 
 ```bash
 npx @inlang/paraglide-js@latest init
 ```
 
-2. (If required) select an adapter.
+### 2. Select an adapter (if required)
+
+Having an adapter is only required if you want to use paraglide-js with a framework. If you don't use a framework, you can skip this step.
+
+<doc-links>
+    <doc-link title="Adapter for Svelte" icon="simple-icons:svelte" href="https://github.com/inlang/monorepo/tree/main/inlang/source-code/paraglide/paraglide-js-adapter-svelte/example" description="Go to GitHub example"></doc-link>
+    <doc-link title="Adapter for SolidJS" icon="tabler:brand-solidjs" href="https://inlang.com/m/n860p17j/library-inlang-paraglideJsAdapterSolidStart" description="Go to Adapter"></doc-link>
+    <doc-link title="Adapter for NextJS" icon="tabler:brand-nextjs" href="https://github.com/inlang/monorepo/tree/main/inlang/source-code/paraglide/paraglide-js-adapter-next" description="Go to GitHub example"></doc-link>
+    <doc-link title="Adapter for Vite" icon="tabler:brand-vite" href="https://github.com/inlang/monorepo/tree/main/inlang/source-code/paraglide/paraglide-js-adapter-vite" description="Go to GitHub"></doc-link>
+</doc-links>
+
+#### Alternatively, [you can write your own adapter](#writing-an-adapter)
+
+### 3. Add the `compile` script to your `package.json`
 
-## Available Adapters
+> If you are using `@inlang/paraglide-js-adapter-vite`, you can skip this step.
 
-- TODO: add adapters 
+You can customize the `compile` script to your needs. For example, you can add a `--watch` flag to watch for changes, if you have installed a watcher.
+
+```json
+{
+	"scripts": {
+		"compile": "paraglide-js compile --project ./project.inlang",
+		"watch": "paraglide-js compile --project ./project.inlang --watch"
+	}
+}
+```
 
 # Usage
 
-Messages are imported as a namespace and can be used as follows:
+Running the `compile` script will generate a `src/paraglide` folder. This folder contains all the code that you need to use paraglide-js.
+Throughout this guide, you will see imports from `./paraglide/*`. These are all to this folder.
+
+> Tip: If you are using a bundler, you can set up an alias to `./src/paraglide` to make the imports shorter. We recommend `$paraglide/*`
+
+## Using Messages
+
+The compiled messages are placed in `./paraglide/messages.js`. You can import them all with `import * as m from "./paraglide/messages"`. Don't worry, your bundler will only bundle the messages that you actually use.
 
 ```js
 // m is a namespace that contains all messages of your project
 // a bundler like rollup or webpack only bundles
 // the messages that are used
-import * as m from "./paraglide-js/messages"
-import { setLanguageTag } from "./paraglide-js/runtime"
+import * as m from "./paraglide/messages"
+import { setLanguageTag } from "./paraglide/runtime"
 
 // use a message
 m.hello() // Hello world!
@@ -45,103 +96,186 @@ m.loginHeader({ name: "Samuel" }) // Hello Samuel, please login to continue.
 setLanguageTag("de")
 
 m.loginHeader({ name: "Samuel" }) // Hallo Samuel, bitte melde dich an, um fortzufahren.
+```
+
+If you want to dynamically choose between a set of messages, you can create a record of messages and index into it. Note that this will not be tree-shaken by your bundler.
+
+```js
+import * as m from "./paraglide/messages"
+
+const season = {
+	spring: m.spring,
+	summer: m.summer,
+	autumn: m.autumn,
+	winter: m.winter,
+}
 
+const msg = season["spring"]() // Hello spring!
 ```
 
-Paraglide JS exports four variables and functions via "@inlang/paraglide-js":
+Paraglide JS provides five exports in `./paraglide/runtime.js`:
 
-- `sourceLanguageTag`: the source language tag of the project
-- `languageTags`: all language tags of the current project
-- `languageTag()`: returns the language tag of the current user
-- `setLanguageTag()`: sets the language tag of the current user
+| Variable                   | Description                                                           |
+| -------------------------- | --------------------------------------------------------------------- |
+| `sourceLanguageTag`        | The source language tag of the project                                |
+| `availableLanguageTags`    | All language tags of the current project                              |
+| `languageTag()`            | Returns the language tag of the current user                          |
+| `setLanguageTag()`         | Sets the language tag of the current user                             |
+| `onSetLanguageTag()`    	 | Registers a listener that is called whenever the language tag changes |
+| `isAvailableLanguageTag()` | Checks if a value is a valid language tag |
 
+## Setting the language
 
+You can set the current [language tag](/m/8y8sxj09/library-inlang-languageTag) by calling `setLanguageTag()`. Any subsequent calls to either `languageTag()` or a message function will return the new language tag.
 
-# Architecture 
+```js
+import { setLanguageTag } from "./paraglide/runtime"
+import * as m from "./paraglide/messages"
 
-Inlang Paraglide JS leverages a compiler to emit vanilla JavaScript functions. 
+setLanguageTag("de")
+m.hello() // Hallo Welt!
 
-The emitted functions are often referred to as "message functions". By emitting message functions, inlang Paraglide JS eliminates a class of edge cases while also being simpler, faster, and more reliable than other i18n libraries. The compiled runtime contains less than 50 LOC (lines of code) and is less than 1kb gzipped.
+setLanguageTag("en")
+m.hello() // Hello world!
+```
 
-Inlang Paraglide-JS consists of four main parts: 
+The [language tag](/m/8y8sxj09/library-inlang-languageTag) is global, so you need to be careful with it on the server to make sure multiple requests don't interfere with each other. That's why we recommend using an adapter for your framework. Adapters integrate with the framework's lifecycle and ensure that the language tag is managed correctly.
 
-- `COMPILER`: compiles messages into tree-shakable message functions
-- `MESSAGES`: the compiled tree-shakable message functions
-- `RUNTIME`: a runtime that resolves the language tag of the current user
-- `ADAPTER`: (if required) an adapter that adjusts the runtime for different frameworks
+## Reacting to a language change
 
-<img src="https://cdn.jsdelivr.net/gh/inlang/monorepo@latest/inlang/source-code/paraglide/paraglide-js/assets/architecture.svg">
+You can react to a language change by calling `onSetLanguageTag()`. This function is called whenever the [language tag](/m/8y8sxj09/library-inlang-languageTag) changes.
 
+```js
+import { setLanguageTag, onSetLanguageTag } from "./paraglide/runtime"
+import * as m from "./paraglide/messages"
 
-## COMPILER
+onSetLanguageTag((newLanguageTag) => {
+	console.log(`The language changed to ${newLanguageTag}`)
+})
 
-The compiler loads an inlang project and compiles the messages into tree-shakable and typesafe message functions.
+setLanguageTag("de") // The language changed to de
+setLanguageTag("en") // The language changed to en
+```
+
+There are a few things to know about `onSetLanguageTag()`:
+
+- You can only register one listener. If you register a second listener it will throw an error.
+- It shouldn't be used on the server.
 
-### Example
+The main use case for `onSetLanguageTag()` is to trigger a rerender of your app's UI when the language changes. Again, if you are using an adapter this is handled for you.
 
-#### Input
+## Forcing a language
+
+It's common that you need to force a message to be in a certain language, especially on the server. You can do this by passing an options object to the message function as a
+second parameter.
 
 ```js
-// messages/en.json
+import * as m from "./paraglide/messages"
+const msg = m.hello({ name: "Samuel" }, { languageTag: "de" }) // Hallo Samuel!
+```
+
+## Usage with a Bundler
+
+We provide a few bundler plugins to make it easier to use paraglide-js with a bundler. If you
+are using one of these bundlers, we recommed using the corresponding plugin.
+
+- [Rollup](https://github.com/inlang/monorepo/tree/main/inlang/source-code/paraglide/paraglide-js-adapter-rollup)
+- [Webpack](https://github.com/inlang/monorepo/tree/main/inlang/source-code/paraglide/paraglide-js-adapter-webpack)
+- [Vite](https://github.com/inlang/monorepo/tree/main/inlang/source-code/paraglide/paraglide-js-adapter-vite)
+
+These plugins make sure to rerun the `compile` script whenever you build your project. That way you don't need to modify your build script in `package.json`. If you are using a bundler with a dev-server, like Vite, the plugins also make sure to rerun the `compile` script whenever your messages change.
+
+# Playground
+
+You can find many examples for how to use paraglide on codesandbox:
+
+<doc-links>
+    <doc-link title="Svelte + Paraglide JS" icon="lucide:codesandbox" href="https://dub.sh/paraglide-playground-svelte" description="Play around with Svelte and Paraglide JS"></doc-link>
+</doc-links>
+
+# Architecture
+
+Inlang Paraglide JS leverages a compiler to emit vanilla JavaScript functions.
+
+The emitted functions are often referred to as "message functions". By emitting message functions, inlang Paraglide JS eliminates a class of edge cases while also being simpler, faster, and more reliable than other i18n libraries. The compiled runtime contains less than 50 LOC (lines of code) and is less than 1kb gzipped.
+
+![paraglide JS architecture](https://cdn.jsdelivr.net/gh/inlang/monorepo@latest/inlang/source-code/paraglide/paraglide-js/assets/architecture.svg)
+
+Inlang Paraglide-JS consists of four main parts:
+
+| Part         | Description                                                                |
+| ------------ | -------------------------------------------------------------------------- |
+| **Compiler** | Compiles messages into tree-shakable message functions                     |
+| **Messages** | The compiled tree-shakable message functions                               |
+| **Runtime**  | A runtime that resolves the [language tag](/m/8y8sxj09/library-inlang-languageTag) of the current user               |
+| **Adapter**  | (if required) An adapter that adjusts the runtime for different frameworks |
+
+## Compiler
+
+The compiler loads an inlang project and compiles the messages into tree-shakable and typesafe message functions.
 
-hello: "Hello {name}!"
+#### Example
 
-loginButton: "Login"
+**Input**
+
+```js
+// messages/en.json
+{
+  "hello": "Hello {name}!",
+  "loginButton": "Login"
+}
 ```
 
-#### Output
+**Output**
 
 ```js
-// @inlang/paraglide-js/messages
+// src/paraglide/messages.js
 
 /**
  * @param {object} params
  * @param {string} params.name
  */
 function hello({ name }) {
-  return `Hello ${name}!`
+	return `Hello ${name}!`
 }
 
 function loginButton() {
-  return "Login"
+	return "Login"
 }
 ```
 
+## Messages
 
-## MESSAGES
-
-The compiled messages are importable as a namespace import (`import * as m`). 
+The compiled messages are importable as a namespace import (`import * as m`).
 
 The namespace import ensures that bundlers like Rollup, Webpack, or Turbopack can tree-shake the messages that are not used.
 
-### Example
+#### Example
 
 Three compiled message functions exist in an example project.
 
 ```js
-// ./paraglide-js/messages.js
-
+// src/paraglide/messages.js
 
 export function hello(params) {
-  return `Hello ${params.name}!`
+	return `Hello ${params.name}!`
 }
 
 export function loginButton() {
-  return "Login"
+	return "Login"
 }
 
 export function loginHeader(params) {
-  return `Hello ${params.name}, please login to continue.`
+	return `Hello ${params.name}, please login to continue.`
 }
 ```
 
-
 Only the message `hello` is used in the source code.
 
 ```js
 // source/index.js
 
-import * as m from "./praglide-js/messages"
+import * as m from "./paraglide/messages"
 
 console.log(m.hello({ name: "Samuel" }))
 ```
@@ -152,79 +286,80 @@ The bundler tree shakes (removes) `loginButton` and `loginHeader` and only inclu
 // output/index.js
 
 function hello(params) {
-  return `Hello ${params.name}!`
+	return `Hello ${params.name}!`
 }
 
-console.log(hello({ name: "Samuel"}))
+console.log(hello({ name: "Samuel" }))
 ```
 
+## Runtime
 
-## RUNTIME
-
-View the source of your imports from `./paraglide-js/` to find the latest runtime API and documentation. 
-
-## ADAPTER 
+View the source of `./paraglide/runtime.js` to find the latest runtime API and documentation.
 
+## Adapter
 
+Paraglide-JS can be adapted to any framework or environment by calling `setLanguageTag()` and `onSetLanguageTag()`.
 
-Paraglide-JS can be adapted to any framework or environment by calling `setLanguageTag()` and `onSetLanguageTag()`. 
-
-1.  `setLanguageTag()` can be used to set a getter function for the language tag. The getter function can be used to resolve server-side language tags or to resolve the language tag from a global state management library like Redux or Vuex.
+1.  `setLanguageTag()` can be used to set a getter function for the [language tag](/m/8y8sxj09/library-inlang-languageTag). The getter function can be used to resolve server-side language tags or to resolve the language tag from a global state management library like Redux or Vuex.
 2.  `onSetLanguageTag()` can be used to trigger side-effects such as updating the UI, or requesting the site in the new language from the server.
 
+# Writing an Adapter
 
-### Writing an Adapter
-
-The following example adapts Paraglide-JS to a fictitious metaframework like NextJS, SolidStart, SvelteKit, or Nuxt. 
+The following example adapts Paraglide-JS to a fictitious metaframework like NextJS, SolidStart, SvelteKit, or Nuxt.
 
 The goal is to provide a high-level understanding of how to adapt Paraglide-JS to a framework. Besides this example, we recommend viewing the source-code of available adapters. In general, only two functions need to be called to adapt Paraglide-JS to a framework:
 
-1. `setLanguageTag()`: to set the language tag
+1. `setLanguageTag()`: to set the [language tag](/m/8y8sxj09/library-inlang-languageTag)
 2. `onSetLanguageTag()`: to trigger a side-effect when the language changes
 
-
-
-
 ```tsx
-import { setLanguageTag, onSetLanguageTag } from "./paraglide-js/runtime"
+import { setLanguageTag, onSetLanguageTag } from "./paraglide/runtime"
 import { isServer, request, render } from "@example/framework"
 
-
-// On a server, the language tag needs to be resolved on a 
-// per-request basis. Hence, we need to pass a getter 
+// On a server, the language tag needs to be resolved on a
+// per-request basis. Hence, we need to pass a getter
 // function () => string to setLanguageTag.
-// 
+//
 // Most frameworks offer a way to access the current
 // request. In this example, we assume that the language tag
 // is available in the request object.
-if (isServer){
-  setLanguageTag(() => request.languageTag)
-} 
-// On a client, the language tag could be resolved from 
+if (isServer) {
+	setLanguageTag(() => request.languageTag)
+}
+// On a client, the language tag could be resolved from
 // the document's html lang tag.
 //
 // In addition, we also want to trigger a side-effect
 // to request the site if the language changes.
 else {
-  setLanguageTag(() => document.documentElement.lang)
-  
-  //! Make sure to call `onSetLanguageTag` after
-  //! the initial language tag has been set to
-  //! avoid an infinite loop. 
-
-  // route to the page in the new language
-  onSetLanguageTag((newLanguageTag) => {
-     window.location.pathname = `/${newLanguageTag}${window.location.pathname}`
-  })
+	setLanguageTag(() => document.documentElement.lang)
+
+	//! Make sure to call `onSetLanguageTag` after
+	//! the initial language tag has been set to
+	//! avoid an infinite loop.
+
+	// route to the page in the new language
+	onSetLanguageTag((newLanguageTag) => {
+		window.location.pathname = `/${newLanguageTag}${window.location.pathname}`
+	})
 }
 
 // render the app
-render((page) => 
-  <html lang={request.languageTag}>
-    <body>
-      {page}
-    </body>
-  </html>
-)
+render((page) => (
+	<html lang={request.languageTag}>
+		<body>{page}</body>
+	</html>
+))
 ```
 
+# Community
+
+We are grateful for all the support we get from the community. Here are just a few of the comments we've received over the last few weeks.
+Of course we are open to and value criticism as well. If you have any feedback, please let us know directly on [GitHub](https://github.com/inlang/monorepo/discussions/1464)
+
+<doc-comments>
+<doc-comment text="The lib is great guys!" author="ktarmyshov" icon="mdi:github"></doc-comment>
+<doc-comment text="Thank you for that huge work you have done and still doing!" author="ZerdoX-x" icon="mdi:github"></doc-comment>
+<doc-comment text="[...] the switch between the sdk-js and paraglide has been pretty great! " author="albbus" icon="mdi:discord"></doc-comment>
+<doc-comment text="Thanks for all the great work @Samuel Stroschein" author="Willem" icon="mdi:discord"></doc-comment>
+</doc-comments>

package/bin/run.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
+import { cli } from "../dist/index.js"
 
-import { cli } from "../dist/cli/main.js"
-
-cli.parse()
+cli.parse()

package/dist/cli/commands/compile.d.ts

@@ -1,3 +1,2 @@
 import { Command } from "commander";
 export declare const compileCommand: Command;
-//# sourceMappingURL=compile.d.ts.map

package/dist/cli/commands/compile.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=compile.test.d.ts.map

package/dist/cli/commands/init.d.ts

@@ -1,31 +1,31 @@
 import { Command } from "commander";
 import { type ProjectSettings } from "@inlang/sdk";
+import { Logger } from "../../services/logger/index.js";
 export declare const initCommand: Command;
-export declare const initializeInlangProject: () => Promise<string>;
+export declare const initializeInlangProject: (logger: Logger) => Promise<string>;
 export declare const maybeAddVsCodeExtension: (args: {
     projectPath: string;
-}) => Promise<void>;
-export declare const addParaglideJsToDependencies: () => Promise<void>;
+}, logger: Logger) => Promise<void>;
+export declare const addParaglideJsToDevDependencies: (logger: Logger) => Promise<void>;
 export declare const findExistingInlangProjectPath: () => Promise<string | undefined>;
 export declare const existingProjectFlow: (args: {
     existingProjectPath: string;
-}) => Promise<undefined>;
-export declare const createNewProjectFlow: () => Promise<undefined>;
+}, logger: Logger) => Promise<undefined>;
+export declare const createNewProjectFlow: (logger: Logger) => Promise<undefined>;
 export declare const newProjectTemplate: ProjectSettings;
-export declare const checkIfPackageJsonExists: () => Promise<undefined>;
-export declare const checkIfUncommittedChanges: () => Promise<void>;
+export declare const checkIfPackageJsonExists: (logger: Logger) => Promise<undefined>;
+export declare const checkIfUncommittedChanges: (logger: Logger) => Promise<void>;
 export declare const addCompileStepToPackageJSON: (args: {
     projectPath: string;
-}) => Promise<undefined>;
+}, logger: Logger) => Promise<undefined>;
 /**
  * Ensures that the moduleResolution compiler option is set to "bundler" or similar in the tsconfig.json.
  *
  * Otherwise, types defined in `package.exports` are not resolved by TypeScript. Leading to type
  * errors with Paraglide-JS.
  */
-export declare const maybeChangeTsConfigModuleResolution: () => Promise<void>;
+export declare const maybeChangeTsConfigModuleResolution: (logger: Logger) => Promise<void>;
 /**
  * Paraligde JS compiles to JS with JSDoc comments. TypeScript doesn't allow JS files by default.
  */
-export declare const maybeChangeTsConfigAllowJs: () => Promise<void>;
-//# sourceMappingURL=init.d.ts.map
+export declare const maybeChangeTsConfigAllowJs: (logger: Logger) => Promise<void>;

package/dist/cli/commands/init.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=init.test.d.ts.map

package/dist/cli/main.d.ts

@@ -1,3 +1,2 @@
 import { Command } from "commander";
 export declare const cli: Command;
-//# sourceMappingURL=main.d.ts.map

package/dist/cli/state.d.ts

@@ -2,4 +2,3 @@
  * The version of the paraglide-js package.
  */
 export declare const version: any;
-//# sourceMappingURL=state.d.ts.map

package/dist/compiler/compile.d.ts

@@ -12,4 +12,3 @@ export declare const compile: (args: {
     messages: Readonly<Message[]>;
     settings: ProjectSettings;
 }) => Record<string, string>;
-//# sourceMappingURL=compile.d.ts.map

package/dist/compiler/compile.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=compile.test.d.ts.map

package/dist/compiler/compileMessage.d.ts

@@ -1,4 +1,8 @@
-import { type Message } from "@inlang/sdk";
+import { LanguageTag, type Message } from "@inlang/sdk";
+type Resource = {
+    index: string;
+    [languageTag: string]: string;
+};
 /**
  * Returns the compiled messages for the given message.
  *
@@ -8,9 +12,9 @@ import { type Message } from "@inlang/sdk";
  *      en: "export const hello_world = (params) => { ... }",
  *      de: "export const hello_world = (params) => { ... }",
  *   }
+ *
+ * @param message The message to compile
+ * @param lookupTable A table that maps language tags to their fallbacks.
  */
-export declare const compileMessage: (message: Message) => {
-    [languageTag: string]: string;
-    index: string;
-};
-//# sourceMappingURL=compileMessage.d.ts.map
+export declare const compileMessage: (message: Message, availableLanguageTags: LanguageTag[], sourceLanguageTag: LanguageTag) => Resource;
+export {};

package/dist/compiler/compileMessage.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=compileMessage.test.d.ts.map

package/dist/compiler/compilePattern.d.ts

@@ -15,4 +15,3 @@ export declare const compilePattern: (pattern: ({
     params: Record<string, "NonNullable<unknown>">;
     compiled: string;
 };
-//# sourceMappingURL=compilePattern.d.ts.map

package/dist/compiler/compilePattern.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=compilePattern.test.d.ts.map

package/dist/compiler/optionsType.d.ts

@@ -0,0 +1,3 @@
+export declare const optionsType: (args: {
+    languageTags: Iterable<string>;
+}) => string;

package/dist/compiler/optionsType.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compiler/paramsType.d.ts

@@ -8,5 +8,4 @@ export type Params = Record<string, "NonNullable<unknown>">;
  *   const jsdoc = jsdocFromParams({ name: "NonNullable<unknown>", count: "NonNullable<unknown>" })
  *   const message = `/** ${paramsType} *\/ const mes2 => \`Hello ${params.name}! You have ${params.count} messages.\``
  */
-export declare const paramsType: (params: Params) => string;
-//# sourceMappingURL=paramsType.d.ts.map
+export declare const paramsType: (params: Params, isMessagesIndex: boolean) => string;

package/dist/compiler/paramsType.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=paramsType.test.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { cli } from "./cli/main.js";
+export { compile } from "./compiler/compile.js";
+export { writeOutput } from "./services/file-handling/write-output.js";
+export { Logger, type LoggerOptions } from "./services/logger/index.js";