fluent-transpiler 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 will Farrell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# fluent-transpiler
+Transpile Fluent (ftl) files into optomized, tree-shakable, JavaScript EcmaScript Modules (esm).
+
+## Install
+```bash
+npm i -D fluent-transpiler
+```
+
+## CLI
+```bash
+Usage: ftl [options] <input>
+
+Compile Fluent (.ftl) files to JavaScript (.js or .mjs)
+
+Arguments:
+  input                                   Path to the Fluent file to compile
+
+Options:
+  --locale <locale...>                    What locale(s) to be used. Multiple can be set to allow for fallback. i.e. en-CA
+  --comments                              Include comments in output file.
+  --variable-notation <variableNotation>  What variable notation to use with exports (choices: "camelCase", "pascalCase", "constantCase",
+                                          "snakeCase", default: "camelCase")
+  --disable-minify                        If disabled, all exported messages will have the same interface `(params) => ({value, attributes})`.
+  --use-isolating                         Wrap placeable with \u2068 and \u2069.
+  -o, --output <output>                   Path to store the resulting JavaScript file. Will be in ESM.
+  -h, --help                              display help for command
+ ```
+
+
+## NodeJS
+
+| Option | Description |
+|--------|-------------|
+| locale | What locale(s) to be used. Multiple can be set to allow for fallback. i.e. en-CA |
+| comments | Include comments in output file. Default: true |
+| disableMinify | If disabled, all exported messages will have the same interface `(params) => ({value, attributes})`. Default: each exported message could be a different type based on what is needed to generate the message (`string`, `object`, `() => ''`, `() => ({})`) |
+| errorOnJunk | Throw error when `Junk` is parsed. Default: true |
+| variableNotation | What variable notation to use with exports. Default: `camelCase` |
+| useIsolating | Wrap placeable with \u2068 and \u2069. Default: false |
+| exportDefault | Allows the overwriting of the `export default` to allow for custom uses. Default: See code |
+
+```javascript
+import {readFile,writeFile} from 'node:fs/promises'
+import fluentTranspiler from 'fluent-transpiler'
+
+const ftl = await readFile('./path/to/en.ftl', {encoding:'utf8'})
+const js = fluentTranspiler(ftl, {locale:'en-CA'})
+await writeFile('./path/to/en.mjs', js, 'utf8')
+```

package/cli.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { createReadStream } from 'fs'
+import { stat, readFile, writeFile } from 'node:fs/promises'
+import { Command, Option } from 'commander'
+import compile from './index.js'
+
+const fileExists = async (filepath) => {
+	const stats = await stat(filepath)
+	if (!stats.isFile()) {
+	  throw new Error(`${filepath} is not a file`)
+	}
+}
+
+new Command()
+  .name('ftl')
+  .description('Compile Fluent (.ftl) files to JavaScript (.js or .mjs)')
+  //.version(package.version)
+  .argument('<input>', 'Path to the Fluent file to compile')
+  .requiredOption('--locale <locale...>', 'What locale(s) to be used. Multiple can be set to allow for fallback. i.e. en-CA')
+  .addOption(new Option('--comments', 'Include comments in output file.')
+    .preset(true)
+  )
+  .addOption(new Option('--variable-notation <variableNotation>', 'What variable notation to use with exports')
+    .choices(['camelCase','pascalCase','constantCase','snakeCase'])
+	.default('camelCase')
+  )
+  .addOption(new Option('--disable-minify', 'If disabled, all exported messages will have the same interface `(params) => ({value, attributes})`.')
+	.preset(true)
+  )
+  .addOption(new Option('--use-isolating', 'Wrap placeable with \\u2068 and \\u2069.')
+  	.preset(true)
+  )
+  .addOption(new Option('-o, --output <output>', 'Path to store the resulting JavaScript file. Will be in ESM.'))
+  .action(async (input, options) => {
+	await fileExists(input)
+	
+	const ftl = await readFile(input, {encoding:'utf8'})
+	
+	const js = compile(ftl, options)
+	if (options.output) {
+		await writeFile(options.output, js, 'utf8')
+	} else {
+		console.log(js)
+	}
+	
+  })
+  .parse()
+

package/index.js

@@ -0,0 +1,315 @@
+import { parse } from '@fluent/syntax'
+import { camelCase, pascalCase, constantCase, snakeCase } from 'change-case'
+
+const exportDefault = `(id, params) => {
+	const source = __exports[id] ?? __exports['_'+id]
+	if (typeof source === 'undefined') return '*** '+id+' ***'
+	if (typeof source === 'function') return source(params)
+	return source
+}
+`
+export const compile = (src, opts) => {
+	const options = {
+		variableNotation: 'camelCase',
+		disableMinify: false, // TODO needs better name
+		params: 'params',
+		comments: true,
+		errorOnJunk: true,
+		useIsolating: false,
+		exportDefault,
+		...opts,
+	}
+	if (!Array.isArray(options.locale)) options.locale = [options.locale]
+	
+	const metadata = {}
+	const functions = {} // global functions
+	let variable
+	
+	const regexpValidVariable = /^[a-zA-Z]+[a-zA-Z0-9]*$/
+	const compileAssignment = (data) => {
+		variable = compileType(data)
+		metadata[variable] = {
+			id: data.name,
+			term: false,
+			params: false
+		}
+		return variable
+	}
+	
+	const compileFunctionArguments = (data) => {
+		const positional = data.arguments?.positional.map(data => {
+			return types[data.type](data)
+		})
+		const named = data.arguments?.named.reduce((obj, data) => {
+			// NamedArgument
+			const key = data.name.name
+			const value = compileType(data.value, data.type)
+			obj[key] = value
+			return obj
+		}, {})
+		return {positional, named}
+	}
+	
+	const compileType = (data, parent) => {
+		try {
+			return types[data.type](data, parent)
+		} catch(e) {
+			console.error('Error:', e.message, data, e.stack)
+			throw new Error(e.message, {cause:data, stack:e.stack})
+		}
+	}
+	
+	const types = {
+		Identifier: (data) => {
+			const value = variableNotation[options.variableNotation](data.name)
+			// Check for reserved words - TODO add in rest
+			if (['const','default','enum','if'].includes(value)) {
+				return '_'+value
+			}
+			return value
+		},
+		Attribute: (data) => {
+			const key = compileType(data.id)
+			const value = compileType(data.value, data.type)
+			return `  ${key}: ${value}`
+		},
+		Pattern: (data, parent) => {
+			return '`' + data.elements.map(data => {
+				return compileType(data, parent)
+			}).join('') + '`'
+		},
+		// resources
+		Term: (data) => {
+			const  assignment = compileAssignment(data.id)
+			const templateStringLiteral = compileType(data.value)
+			metadata[variable].term = true
+			if (metadata[assignment].params) {
+				return `const ${assignment} = (${options.params}) => ${templateStringLiteral}\n`
+			}
+			return `const ${assignment} = ${templateStringLiteral}\n`
+		},
+		Message: (data) => {
+			const assignment = compileAssignment(data.id)
+			const templateStringLiteral = data.value && compileType(data.value, data.type)
+			metadata[assignment].attributes = data.attributes.length
+			let attributes = {}
+			if (metadata[assignment].attributes) {
+				// use Object.create(null) ?
+				attributes = `{\n${data.attributes.map(data => {
+						return '  '+compileType(data)
+					}).join(',\n')}\n  }`
+			}
+			//
+			if (!options.disableMinify) {
+				if (metadata[variable].attributes) {
+					if (metadata[assignment].params) {
+						return `export const ${assignment} = (${options.params}) => ({
+  value:${templateStringLiteral},
+  attributes:${attributes}
+})\n`
+					}
+					return `export const ${assignment} = {
+  value: ${templateStringLiteral},
+  attributes: ${attributes}
+}\n`
+				}
+				if (metadata[assignment].params) {
+					return `export const ${assignment} = (${options.params}) => ${templateStringLiteral}\n`
+				}
+				return `export const ${assignment} = ${templateStringLiteral}\n`
+			}
+			// consistent API
+			return `export const ${variable} = (${metadata[assignment].params ? options.params : ''}) => ({
+  value:${templateStringLiteral},
+  attributes:${attributes}
+})\n`
+		},
+		Comment: (data) => {
+			if (options.comments) return `// # ${data.content}\n`
+			return ''
+		},
+		GroupComment: (data) => {
+			if (options.comments) return `// ## ${data.content}\n`
+			return ''
+		},
+		ResourceComment: (data) => {
+			if (options.comments) return `// ### ${data.content}\n`
+			return ''
+		},
+		Junk: (data) => {
+			if (options.errorOnJunk) {
+				throw new Error('Junk found', {cause:data})
+			}
+			console.error('Error: Skipping Junk', JSON.stringify(data, null, 2))
+			return ''
+		},
+		// Element
+		TextElement: (data) => {
+			return data.value
+		},
+		Placeable: (data, parent) => {
+			return `${options.useIsolating ? '\u2068' : '' }\${${compileType(data.expression, parent)}}${options.useIsolating ? '\u2069' : '' }`
+		},
+		// Expression
+		StringLiteral: (data, parent) => {
+			// JSON.stringify at parent level
+			if (['NamedArgument'].includes(parent)) {
+				return `${data.value}`
+			}
+			return `"${data.value}"`
+		},
+		NumberLiteral: (data) => {
+			const decimal =  Number.parseFloat(data.value)
+			const number = Number.isInteger(decimal) ? Number.parseInt(data.value) : decimal 
+			return Intl.NumberFormat(options.locale).format(number)
+		},
+		VariableReference: (data, parent) => {
+			functions.__formatVariable = true
+			metadata[variable].params = true
+			const value = `${options.params}?.${data.id.name}`
+			if (['Message','Variant','Attribute'].includes(parent)) {
+				return `__formatVariable(${value})`
+			}
+			return value
+		},
+		MessageReference: (data) => {
+			const messageName = compileType(data.id)
+			metadata[variable].params ||= metadata[messageName].params
+			if (!options.disableMinify) {
+				if (metadata[messageName].params) {
+					return `${messageName}(${options.params})`
+				}
+				return `${messageName}`
+			}
+			return `${messageName}(${metadata[messageName].params ? options.params : ''})`
+		},
+		TermReference: (data) => {
+			const termName = compileType(data.id)
+			const {named} = compileFunctionArguments(data)
+			if (!options.disableMinify) {
+				if (metadata[termName].params) {
+					return `${termName}(${JSON.stringify(named)})`
+				}
+				return `${termName}`
+			}
+			return `${termName}(${named ? JSON.stringify(named) : ''})`
+		},
+		NamedArgument:(data) => {
+			// Inconsistent: `NamedArgument` uses `name` instead of `id` for Identifier
+			const key = data.name.name // Don't transform value
+			const value = compileType(data.value, data.type)
+			return `${key}: ${value}`
+		},
+		SelectExpression: (data) => {
+			functions.__select = true
+			metadata[variable].params = true
+			const value = compileType(data.selector)
+			//const options = data.selector
+			let fallback
+			return `__select(\n    ${value},\n    {\n${data.variants.filter(data => {
+					if (data.default) {
+						fallback = compileType(data.value, data.type)
+					}
+					return !data.default
+				}).map(data => {
+					return '  '+compileType(data)
+				}).join(',\n')}\n    },\n    ${fallback}\n  )`
+		},
+		Variant: (data, parent) => {
+			// Inconsistent: `Variant` uses `key` instead of `id` for Identifier
+			const key = compileType(data.key)
+			const value = compileType(data.value, data.type)
+			return `    '${key}': ${value}`
+		},
+		FunctionReference: (data) => {
+			return `${types[data.id.name](compileFunctionArguments(data))}`
+		},
+		// Functions
+		DATETIME: (data) => {
+			functions.__formatDateTime = true
+			const {positional, named} = data
+			const value = positional.shift()
+			return `__formatDateTime(${value}, ${JSON.stringify(named)})`
+		},
+		NUMBER: (data) => {
+			functions.__formatNumber = true
+			const {positional, named} = data
+			const value = positional.shift()
+			return `__formatNumber(${value}, ${JSON.stringify(named)})`
+		},
+	}
+	
+	if (/\t/.test(src)) {
+		console.error('Source file contains tab characters (\t), replacing with <space>x4')
+		src = src.replace(/\t/g, '    ')
+	}
+	
+	const {body} = parse(src)
+	
+	let translations = ``
+	for(const data of body) {
+		translations += compileType(data)
+	}
+	
+	let output = ``
+	if (functions.__formatVariable || functions.__formatDateTime || functions.__formatNumber) {
+		output += `const __locales = ${JSON.stringify(opts.locale)}\n`
+	}
+
+	if (functions.__formatDateTime) {
+		output += `
+const __formatDateTime = (value, options) => {
+	return new Intl.DateTimeFormat(__locales, options).format(value)
+}
+`
+	}
+	if (functions.__formatVariable || functions.__formatNumber) {
+		output += `
+const __formatNumber = (value, options) => {
+	return new Intl.NumberFormat(__locales, options).format(value)
+}
+`
+	}
+	if (functions.__formatVariable) {
+			output += `
+const __formatVariable = (value) => {
+  if (typeof value === 'string') return value
+  const decimal =  Number.parseFloat(value)
+  const number = Number.isInteger(decimal) ? Number.parseInt(value) : decimal
+  return __formatNumber(number)
+}
+`
+	}
+	if (functions.__select) {
+		output += `
+const __select = (value, cases, fallback, options) => {
+	const pluralRules = new Intl.PluralRules(__locales, options)
+	const rule = pluralRules.select(value)
+	return cases[value] ?? cases[rule] ?? fallback
+}
+`
+	}
+	output += `\n`+translations
+	output += `const __exports = {${Object.keys(metadata)
+			.filter(key => !metadata[key].term)
+			.map(key => {
+				if (key === metadata[key].id) return key
+				return `'${metadata[key].id}':${key}`
+			})
+			.join(', ')
+		}}\n`
+	output += `\nexport default ${options.exportDefault}`
+	
+	return output
+}
+
+
+const variableNotation = {
+	camelCase,
+	pascalCase,
+	snakeCase, 
+	constantCase
+}
+// for `export defaults`
+
+export default compile

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "fluent-transpiler",
+  "version": "0.0.0",
+  "description": "Transpile Fluent (ftl) files into optomized, tree-shakable, JavaScript EcmaScript Modules (esm).",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "ftl": "cli.js"
+  },
+  "scripts": {
+    "test": "npm run test:cli && npm run test:unit",
+    "test:cli": "./cli.js --locale en-CA --locale en --use-isolating --variable-notation camelCase test/files/index.ftl --output test/files/index.mjs",
+    "test:unit": "c8 node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/willfarrell/fluent-transpiler.git"
+  },
+  "keywords": [
+    "Fluent",
+    "@fluent",
+    "ftl",
+    "localization",
+    "l10n",
+    "internationalization",
+    "i18n",
+    "ast",
+    "compiler",
+    "transpiler"
+  ],
+  "author": "willfarrell",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/willfarrell/fluent-transpiler/issues"
+  },
+  "homepage": "https://middy.js.org",
+  "dependencies": {
+    "@fluent/syntax": "0.18.1",
+    "change-case": "4.1.2",
+    "commander": "9.4.0"
+  },
+  "devDependencies": {
+    "@fluent/bundle": "^0.17.1",
+    "c8": "^7.12.0"
+  }
+}

package/test/files/index.ftl

@@ -0,0 +1,117 @@
+# https://projectfluent.org/fluent/guide/
+# Writing Text
+text = text: hard coded.
+
+## Placeables
+replaceParam = param: { $string } | { $integer } | {$decimal} | {$number} .
+
+-term = Firefox
+replaceTerm = term: { -term }.
+
+-brand-name = 
+    { $case ->
+        *[nominative] Firefox
+        [locative] Firefoksie
+    }
+parameterized-terms = Informacje o { -brand-name(case: "locative") }.
+
+### Message References
+messageValue = message: { replaceTerm }
+messageNestedParamValue = message: { replaceParam }
+
+
+## Special Characters
+openingBrace = This message features an opening curly brace: {"{"}.
+closingBrace = This message features a closing curly brace: {"}"}.
+
+blankIsRemoved =     This message starts with no blanks.
+blankIsPreserved = {"    "}This message starts with 4 spaces.
+
+leadingBracket =
+  This message has an opening square bracket
+  at the beginning of the third line:
+  {"["}.
+
+literalQuote = Text in "double quotes".
+# This is OK, but cryptic and hard to read and edit.
+literalEscapedQuote = Text in {"\""}double quotes{"\""}.
+
+
+privacyLabel = Privacy{"\u00A0"}Policy
+
+# The dash character is an EM DASH but depending on the font face,
+# it might look like an EN DASH.
+dash = It's a dash—or is it?
+
+dashUnicode = It's a dash{"\u2014"}or is it?
+
+emoji = 😂
+emojiUnicode = {"\u01F602"}
+
+## Multiline Text
+singleLine = Text can be written in a single line.
+
+multiLine = Text can also span multiple lines
+  as long as each new line is indented
+  by at least one space.
+
+block =
+  Sometimes it's more readable to format
+  multiline text as a "block", which means
+  starting it on a new line. All lines must
+  be indented by at least one space.
+  
+leadingBlankSpaces =     This message's value starts with the word "This".
+leadingBlankLines =
+
+
+  This message's value starts with the word "This".
+  The blank lines under the identifier are ignored.
+
+blankLines =
+
+  The blank line above this line is ignored.
+  This is a second line of the value.
+  
+  The blank line above this line is preserved.
+
+multiLineIndent =
+    This message has 4 spaces of indent
+    on the second line of its value.
+
+## Functions
+timeElapsed = Time elapsed: { NUMBER($number, maximumFractionDigits: 0) }s.
+
+todayIs = Today is { DATETIME($date) }
+
+## Selectors
+selectorNumberCardinal =
+{ $number ->
+  [zero] There are {$number} (zero).
+  [one] There are {$number} (one).
+   *[other] There are { $number } (other).
+}
+
+selectorNumberOrdinal =
+{ NUMBER($number, type: "ordinal") ->
+  [-1] There are {$number} (-1).
+  [zero] There are {$number} (zero).
+  [one] There are {$number} (one).
+  [two] There are {$number} (two).
+  [3.0] There are {$number} (3).
+  [few] There are {$number} (few).
+  [many] There are {$number} (many).
+  [toomany] There are {$number} (toomany).
+   *[other] There are { $number } (other).
+}
+
+## Attributes
+loginInput = Predefined value
+  .placeholder = email@example.com
+  .ariaLabel = Login input value
+  .title = Type your login email
+
+attributeHowTo =
+    To add an attribute to this messages, write
+    {".attr = Value"} on a new line.
+    .attr = An actual attribute (not part of the text value above)

package/test/files/index.mjs

@@ -0,0 +1,122 @@
+const __locales = "en-CA"
+
+const __formatDateTime = (value, options) => {
+	return new Intl.DateTimeFormat(__locales, options).format(value)
+}
+
+const __formatNumber = (value, options) => {
+	return new Intl.NumberFormat(__locales, options).format(value)
+}
+
+const __formatVariable = (value) => {
+  if (typeof value === 'string') return value
+  const decimal =  Number.parseFloat(value)
+  const number = Number.isInteger(decimal) ? Number.parseInt(value) : decimal
+  return __formatNumber(number)
+}
+
+const __select = (value, cases, fallback, options) => {
+	const pluralRules = new Intl.PluralRules(__locales, options)
+	const rule = pluralRules.select(value)
+	return cases[value] ?? cases[rule] ?? fallback
+}
+
+export const text = `text: hard coded.`
+// ## Placeables
+export const replaceParam = (params) => `param: ${__formatVariable(params?.string)} | ${__formatVariable(params?.integer)} | ${__formatVariable(params?.decimal)} | ${__formatVariable(params?.number)} .`
+const term = `Firefox`
+export const replaceTerm = `term: ${term}.`
+const brandName = (params) => `${__select(
+    params?.case,
+    {
+      'locative': `Firefoksie`
+    },
+    `Firefox`
+  )}`
+export const parameterizedTerms = `Informacje o ${brandName({"case":"locative"})}.`
+// ### Message References
+export const messageValue = `message: ${replaceTerm}`
+export const messageNestedParamValue = (params) => `message: ${replaceParam(params)}`
+// ## Special Characters
+export const openingBrace = `This message features an opening curly brace: ${"{"}.`
+export const closingBrace = `This message features a closing curly brace: ${"}"}.`
+export const blankIsRemoved = `This message starts with no blanks.`
+export const blankIsPreserved = `${"    "}This message starts with 4 spaces.`
+export const leadingBracket = `This message has an opening square bracket
+at the beginning of the third line:
+${"["}.`
+export const literalQuote = `Text in "double quotes".`
+export const literalEscapedQuote = `Text in ${"\""}double quotes${"\""}.`
+export const privacyLabel = `Privacy${"\u00A0"}Policy`
+export const dash = `It's a dash—or is it?`
+export const dashUnicode = `It's a dash${"\u2014"}or is it?`
+export const emoji = `😂`
+export const emojiUnicode = `${"\u01F602"}`
+// ## Multiline Text
+export const singleLine = `Text can be written in a single line.`
+export const multiLine = `Text can also span multiple lines
+as long as each new line is indented
+by at least one space.`
+export const block = `Sometimes it's more readable to format
+multiline text as a "block", which means
+starting it on a new line. All lines must
+be indented by at least one space.`
+export const leadingBlankSpaces = `This message's value starts with the word "This".`
+export const leadingBlankLines = `This message's value starts with the word "This".
+The blank lines under the identifier are ignored.`
+export const blankLines = `The blank line above this line is ignored.
+This is a second line of the value.
+
+The blank line above this line is preserved.`
+export const multiLineIndent = `This message has 4 spaces of indent
+on the second line of its value.`
+// ## Functions
+export const timeElapsed = (params) => `Time elapsed: ${__formatNumber(params?.number, {"maximumFractionDigits":"0"})}s.`
+export const todayIs = (params) => `Today is ${__formatDateTime(params?.date, {})}`
+// ## Selectors
+export const selectorNumberCardinal = (params) => `${__select(
+    params?.number,
+    {
+      'zero': `There are ${__formatVariable(params?.number)} (zero).`,
+      'one': `There are ${__formatVariable(params?.number)} (one).`
+    },
+    `There are ${__formatVariable(params?.number)} (other).`
+  )}`
+export const selectorNumberOrdinal = (params) => `${__select(
+    __formatNumber(params?.number, {"type":"ordinal"}),
+    {
+      '-1': `There are ${__formatVariable(params?.number)} (-1).`,
+      'zero': `There are ${__formatVariable(params?.number)} (zero).`,
+      'one': `There are ${__formatVariable(params?.number)} (one).`,
+      'two': `There are ${__formatVariable(params?.number)} (two).`,
+      '3': `There are ${__formatVariable(params?.number)} (3).`,
+      'few': `There are ${__formatVariable(params?.number)} (few).`,
+      'many': `There are ${__formatVariable(params?.number)} (many).`,
+      'toomany': `There are ${__formatVariable(params?.number)} (toomany).`
+    },
+    `There are ${__formatVariable(params?.number)} (other).`
+  )}`
+// ## Attributes
+export const loginInput = {
+  value: `Predefined value`,
+  attributes: {
+    placeholder: `email@example.com`,
+    ariaLabel: `Login input value`,
+    title: `Type your login email`
+  }
+}
+export const attributeHowTo = {
+  value: `To add an attribute to this messages, write
+${".attr = Value"} on a new line.`,
+  attributes: {
+    attr: `An actual attribute (not part of the text value above)`
+  }
+}
+const __exports = {text, replaceParam, replaceTerm, 'parameterized-terms':parameterizedTerms, messageValue, messageNestedParamValue, openingBrace, closingBrace, blankIsRemoved, blankIsPreserved, leadingBracket, literalQuote, literalEscapedQuote, privacyLabel, dash, dashUnicode, emoji, emojiUnicode, singleLine, multiLine, block, leadingBlankSpaces, leadingBlankLines, blankLines, multiLineIndent, timeElapsed, todayIs, selectorNumberCardinal, selectorNumberOrdinal, loginInput, attributeHowTo}
+
+export default (id, params) => {
+	const source = __exports[id] ?? __exports['_'+id]
+	if (typeof source === 'undefined') return '*** '+id+' ***'
+	if (typeof source === 'function') return source(params)
+	return source
+}

package/test/index.js

@@ -0,0 +1,84 @@
+import test from 'node:test'
+import { deepEqual } from 'node:assert'
+import {readFile,writeFile} from 'node:fs/promises'
+import compile from '../index.js'
+
+import { FluentBundle, FluentResource } from "@fluent/bundle"
+
+// input
+const ftl = await readFile('./test/files/index.ftl', {encoding:'utf8'})
+
+// compiled
+const js = compile(ftl, {locale:'en-CA', variableNotation: 'camelCase', useIsolating:false})
+await writeFile('./test/files/index.mjs', js, 'utf8')
+const {default:fluentCompiled} = await import('./files/index.mjs') // TODO fix default
+
+// core
+let bundle = new FluentBundle('en-CA', {useIsolating:false});
+let errors = bundle.addResource(new FluentResource(ftl));
+if (errors.length) {
+  console.log('Error: bundle.addResource', errors)
+}
+const fluentBundle = (id, params) => {
+  const message = bundle.getMessage(id)
+  if (!message) {
+    console.log('Error', id, message)
+    return 'error'
+  }
+  const attributes = {}
+  for(const attr in message.attributes) {
+    attributes[attr] = bundle.formatPattern(message.attributes[attr], params)
+  }
+  const value = bundle.formatPattern(message.value, params)
+  if (Object.keys(message.attributes).length) {
+    return {value, attributes}
+  }
+  return value
+}
+
+// compile
+test(`Should throw error when Junk is parsed`, async (t) => {
+  try {
+    const js = compile(`-brand-name = {}`, {locale:'en-CA', errorOnJunk:true})
+    console.log(js)
+    throw new Error('fail')
+  } catch (e) {
+    deepEqual(e.message, 'Junk found')
+  }
+})
+
+test(`Should include comments`, async (t) => {
+    const js = compile(`
+# Comment
+## GroupComment
+### ResourceComment
+`, {locale:'en-CA', comments:true})
+    deepEqual(js.includes(`// # Comment
+// ## GroupComment
+// ### ResourceComment`), true)
+
+})
+
+// tests
+const params = {string:'0.0',integer:-2, decimal: 3.5, number:9999999.00, date: new Date()}
+for (const id of Object.keys(fluentCompiled)) {
+  if (id === 'default') continue
+  test(`Should format ${id}`, async (t) => {
+    deepEqual(fluentCompiled(id, params), fluentBundle(id, params))
+  })
+}
+
+// selector
+for(const param of [-1,0,1,2,3,4,5,10]) {
+  let id = 'selectorNumberCardinal'
+  test(`Should format ${id} with ${param}`, async (t) => {
+     params.number = param
+    deepEqual(fluentCompiled(id, params), fluentBundle(id, params))
+  })
+
+  id = 'selectorNumberOrdinal'
+  test(`Should format ${id} with ${param}`, async (t) => {
+     params.number = param
+    deepEqual(fluentCompiled(id, params), fluentBundle(id, params))
+  })
+}