fluent-transpiler 0.0.1 → 0.1.0

package/README.md

@@ -1,12 +1,15 @@
 # fluent-transpiler
-Transpile Fluent (ftl) files into optomized, tree-shakable, JavaScript EcmaScript Modules (esm).
+
+Transpile Fluent (ftl) files into optimized, tree-shakable, JavaScript EcmaScript Modules (esm).
 
 ## Install
+
 ```bash
 npm i -D fluent-transpiler
 ```
 
 ## CLI
+
 ```bash
 Usage: ftl [options] <input>
 
@@ -24,26 +27,25 @@ Options:
   --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 |
+| 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 { 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'})
+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

@@ -21,9 +21,14 @@ new Command()
   .addOption(new Option('--comments', 'Include comments in output file.')
     .preset(true)
   )
+  .addOption(new Option('--include <includeMessages...>', 'Allowed messages to be included. Default to include all.'))
+  .addOption(new Option('--exclude <excludeMessages...>', 'Ignored messages to be excluded. Default to exclude none.'))
+  /*.addOption(new Option('--tree-shaking', 'Export all messages to allow tree shaking')
+    .preset(true)
+  )*/
   .addOption(new Option('--variable-notation <variableNotation>', 'What variable notation to use with exports')
     .choices(['camelCase','pascalCase','constantCase','snakeCase'])
-	.default('camelCase')
+	  .default('camelCase')
   )
   .addOption(new Option('--disable-minify', 'If disabled, all exported messages will have the same interface `(params) => ({value, attributes})`.')
 	.preset(true)

package/index.js

@@ -9,279 +9,417 @@ const exportDefault = `(id, params) => {
 }
 `
 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[assignment].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}) => ({
+  const options = {
+    comments: true,
+    errorOnJunk: true,
+    includeMessages: [],
+    excludeMessages: [],
+    //treeShaking: false,
+    variableNotation: 'camelCase',
+    disableMinify: false, // TODO needs better name strictInterface?
+    useIsolating: false,
+    params: 'params',
+    exportDefault,
+    ...opts
+  }
+  if (!Array.isArray(options.locale)) options.locale = [options.locale]
+  if (!Array.isArray(options.includeMessages))
+    options.includeMessages = [options.includeMessages]
+  if (!Array.isArray(options.excludeMessages))
+    options.excludeMessages = [options.excludeMessages]
+
+  const metadata = {}
+  const exports = []
+  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[assignment].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)
+
+      if (
+        options.includeMessages.length &&
+        !options.includeMessages.includes(assignment)
+      ) {
+        return ''
+      }
+
+      if (
+        options.excludeMessages.length &&
+        options.excludeMessages.includes(assignment)
+      ) {
+        return ''
+      }
+
+      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  }`
+      }
+      //
+      let message = ''
+      if (!options.disableMinify) {
+        if (metadata[assignment].attributes) {
+          if (metadata[assignment].params) {
+            message = `(${options.params}) => ({
   value:${templateStringLiteral},
   attributes:${attributes}
 })\n`
-					}
-					return `export const ${assignment} = {
+          } else {
+            message = `{
   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 : ''}) => ({
+          }
+        } else if (metadata[assignment].params) {
+          message = `(${options.params}) => ${templateStringLiteral}\n`
+        } else {
+          message = `${templateStringLiteral}\n`
+        }
+      } else {
+        // consistent API
+        message = `(${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)
-			metadata[variable].params ||= metadata[termName].params
-			
-			let params
-			if (metadata[termName].params) {
-				let {named} = compileFunctionArguments(data)
-				named = JSON.stringify(named)
-				if (named) {
-					params = `{ ...${options.params}, ${named.substring(1, named.length-1)} }`
+      }
+      //if (options.treeShaking) {
+      if (assignment === metadata[assignment].id) {
+        exports.push(`${assignment}`)
+      } else {
+        exports.push(`'${metadata[assignment].id}': ${assignment}`)
+      }
+      return `export const ${assignment} = ${message}`
+      /*} else {
+				if (assignment === metadata[assignment].id) {
+					exports.push(`${assignment}: ${message}`)
 				} else {
-					params = options.params
-				}
-			}
-			if (!options.disableMinify) {
-				if (metadata[termName].params) {
-					return `${termName}(${params})`
+					exports.push(`'${metadata[assignment].id}': ${message}`)
 				}
-				return `${termName}`
-			}
-			return `${termName}(${params ? params : ''})`
-		},
-		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)})`
-		},
+			}*/
+      return ''
+    },
+    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)
+      metadata[variable].params ||= metadata[termName].params
+
+      let params
+      if (metadata[termName].params) {
+        let { named } = compileFunctionArguments(data)
+        named = JSON.stringify(named)
+        if (named) {
+          params = `{ ...${options.params}, ${named.substring(
+            1,
+            named.length - 1
+          )} }`
+        } else {
+          params = options.params
+        }
+      }
+      if (!options.disableMinify) {
+        if (metadata[termName].params) {
+          return `${termName}(${params})`
+        }
+        return `${termName}`
+      }
+      return `${termName}(${params ? params : ''})`
+    },
+    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)})`
+    },
+    RELATIVETIME: (data) => {
+      functions.__formatRelativeTime = true
+      const { positional, named } = data
+      const value = positional.shift()
+      return `__formatRelativeTime(${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`
+  }
+  /*
+const relativeTimeFormat = new Intl.RelativeTimeFormat(lang, {
+  localeMatcher: 'best fit',
+  numeric: 'always',
+  style: 'long'
+})
+
+const formatTime = (value) => {
+  value = new Date(value)
+  if (isNaN(value.getTime())) return value
+  try {
+	const [duration, unit] = relativeTimeDiff(value)
+	return relativeTimeFormat.format(duration, unit)
+  } catch (e) {
+	return dateTimeFormat.format(value)
+  }
+}
+*/
+  if (functions.__formatRelativeTime) {
+    output += `
+  const __relativeTimeDiff = (d) => {
+	const msPerMinute = 60 * 1000
+	const msPerHour = msPerMinute * 60
+	const msPerDay = msPerHour * 24
+	const msPerWeek = msPerDay * 7
+	const msPerMonth = msPerDay * 30
+	const msPerYear = msPerDay * 365.25
+	const elapsed = d - new Date()
+  
+	if (Math.abs(elapsed) < msPerMinute) {
+	  return [Math.round(elapsed / 1000), 'second']
 	}
-	
-	if (/\t/.test(src)) {
-		console.error('Source file contains tab characters (\t), replacing with <space>x4')
-		src = src.replace(/\t/g, '    ')
+	if (Math.abs(elapsed) < msPerHour) {
+	  return [Math.round(elapsed / msPerMinute), 'minute']
 	}
-	
-	const {body} = parse(src)
-	let translations = ``
-	for(const data of body) {
-		translations += compileType(data)
+	if (Math.abs(elapsed) < msPerDay) {
+	  return [Math.round(elapsed / msPerHour), 'hour']
 	}
-	
-	let output = ``
-	if (functions.__formatVariable || functions.__formatDateTime || functions.__formatNumber) {
-		output += `const __locales = ${JSON.stringify(opts.locale)}\n`
+	if (Math.abs(elapsed) < msPerWeek * 2) {
+	  return [Math.round(elapsed / msPerDay), 'day']
 	}
-
-	if (functions.__formatDateTime) {
-		output += `
+	if (Math.abs(elapsed) < msPerMonth) {
+	  return [Math.round(elapsed / msPerWeek), 'week']
+	}
+	if (Math.abs(elapsed) < msPerYear) {
+	  return [Math.round(elapsed / msPerMonth), 'month']
+	}
+	return [Math.round(elapsed / msPerYear), 'year']
+  }
+  const __formatRelativeTime = (value, options) => {
+	  if (typeof value === 'string') value = new Date(value)
+	  if (isNaN(value.getTime())) return value
+	  try {
+		const [duration, unit] = relativeTimeDiff(value)
+		return relativeTimeFormat.format(duration, unit)
+	  } catch (e) {
+		return dateTimeFormat.format(value)
+	  }
+	  return new Intl.DateTimeFormat(__locales, options).format(value)
+  }
+  `
+  }
+  if (functions.__formatDateTime) {
+    output += `
 const __formatDateTime = (value, options) => {
+	if (typeof value === 'string') value = new Date(value)
+	if (isNaN(value.getTime())) return value
 	return new Intl.DateTimeFormat(__locales, options).format(value)
 }
 `
-	}
-	if (functions.__formatVariable || functions.__formatNumber) {
-		output += `
+  }
+  if (functions.__formatVariable || functions.__formatNumber) {
+    output += `
 const __formatNumber = (value, options) => {
 	return new Intl.NumberFormat(__locales, options).format(value)
 }
 `
-	}
-	if (functions.__formatVariable) {
-			output += `
+  }
+  if (functions.__formatVariable) {
+    output += `
 const __formatVariable = (value) => {
   if (typeof value === 'string') return value
   const decimal =  Number.parseFloat(value)
@@ -289,37 +427,28 @@ const __formatVariable = (value) => {
   return __formatNumber(number)
 }
 `
-	}
-	if (functions.__select) {
-		output += `
+  }
+  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
-}
+  }
+  output += `\n` + translations
+  output += `const __exports = {\n  ${exports.join(',\n  ')}\n}`
+  output += `\nexport default ${options.exportDefault}`
 
+  return output
+}
 
 const variableNotation = {
-	camelCase,
-	pascalCase,
-	snakeCase, 
-	constantCase
+  camelCase,
+  pascalCase,
+  snakeCase,
+  constantCase
 }
-// for `export defaults`
 
-export default compile
+export default compile

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "fluent-transpiler",
-  "version": "0.0.1",
-  "description": "Transpile Fluent (ftl) files into optomized, tree-shakable, JavaScript EcmaScript Modules (esm).",
+  "version": "0.1.0",
+  "description": "Transpile Fluent (ftl) files into optimized, tree-shakable, JavaScript EcmaScript Modules (esm).",
   "main": "index.js",
   "type": "module",
   "bin": {
     "ftl": "cli.js"
   },
+  "files": [
+    "cli.js",
+    "index.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",
@@ -33,7 +37,7 @@
   "bugs": {
     "url": "https://github.com/willfarrell/fluent-transpiler/issues"
   },
-  "homepage": "https://middy.js.org",
+  "homepage": "https://github.com/willfarrell/fluent-transpiler",
   "dependencies": {
     "@fluent/syntax": "0.18.1",
     "change-case": "4.1.2",

package/test/files/index.ftl

@@ -1,123 +0,0 @@
-# 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") }.
-
-
--term-with-var = {$number}
-termWithVariable = {-term-with-var}
-
-### 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).
-}
-
-subSelector = {selectorNumberOrdinal}
-
-## 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

@@ -1,125 +0,0 @@
-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 = (params) => `Informacje o ${brandName({ ...params, "case":"locative" })}.`
-const termWithVar = (params) => `${params?.number}`
-export const termWithVariable = (params) => `${termWithVar(params)}`
-// ### 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).`
-  )}`
-export const subSelector = (params) => `${selectorNumberOrdinal(params)}`
-// ## 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, termWithVariable, 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, subSelector, 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

@@ -1,84 +0,0 @@
-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))
-  })
-}