@ultraq/icu-message-formatter 0.13.0 → 0.14.1

package/source/utilities.test.js

@@ -1,123 +0,0 @@
-/* 
- * Copyright 2019, Emanuel Rabina (http://www.ultraq.net.nz/)
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *     http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-env jest */
-import {parseCases} from './utilities';
-
-/**
- * Tests for the `parseCases` util.
- */
-describe('parseCases', function() {
-	describe('empty', function() {
-		test('empty string', function() {
-			let result = parseCases('');
-			expect(result.args).toStrictEqual([]);
-			expect(result.cases).toStrictEqual({});
-		});
-	});
-
-	describe('basic case support', function() {
-		test('single case', function() {
-			let result = parseCases('key {case string!}');
-			expect(result.args).toStrictEqual([]);
-			expect(result.cases).toStrictEqual({key: 'case string!'});
-		});
-
-		test('fails if cant close case', function() {
-			expect(() => {
-				parseCases('key1 {{case1}');
-			}).toThrowError();
-		});
-
-		test('multiple cases', function() {
-			let result = parseCases('key1 {case1} key2 {case2} key3 {case3}');
-			expect(result.args).toStrictEqual([]);
-			expect(result.cases).toStrictEqual({key1: 'case1', key2: 'case2', key3: 'case3'});
-		});
-
-		test('multiple cases with symbols', function() {
-			let result = parseCases('=key1 {case1} &key2 {case2} key3 {case3}');
-			expect(result.args).toStrictEqual([]);
-			expect(result.cases).toStrictEqual({'=key1': 'case1', '&key2': 'case2', key3: 'case3'});
-		});
-
-		test('multiple cases with inconsistent whitespace', function() {
-			let result = parseCases(`key1     {case1}  
-            
-            
-    key2 {case2}
-                                key3 {case3}`);
-			expect(result.args).toStrictEqual([]);
-			expect(result.cases).toStrictEqual({key1: 'case1', key2: 'case2', key3: 'case3'});
-		});
-
-		test('multiple cases with minimal whitespace', function() {
-			let result = parseCases(`key1{case1}key2{case2}key3{case3}`);
-			expect(result.args).toStrictEqual([]);
-			expect(result.cases).toStrictEqual({key1: 'case1', key2: 'case2', key3: 'case3'});
-		});
-
-		test('multiple cases with complex bodies', function() {
-			let result = parseCases(`key1     {{}{}{}{{{{}}}}}  
-            
-            
-    key2 {=key1 {case1} &key2 {case2} key3 {case3}}
-                                key3 {}`);
-			expect(result.args).toStrictEqual([]);
-			expect(result.cases).toStrictEqual({key1: '{}{}{}{{{{}}}}', key2: '=key1 {case1} &key2 {case2} key3 {case3}', key3: ''});
-		});
-	});
-
-	describe('basic arg support', function() {
-		test('single arg', function() {
-			let result = parseCases('arg1');
-			expect(result.args).toStrictEqual(['arg1']);
-		});
-
-		test('multiple args', function() {
-			let result = parseCases('arg1 arg2 arg3');
-			expect(result.args).toStrictEqual(['arg1', 'arg2', 'arg3']);
-		});
-
-		test('multiple args with inconsistent whitespace', function() {
-			let result = parseCases(`arg1     
-            
-            
-            arg2                    arg3`);
-			expect(result.args).toStrictEqual(['arg1', 'arg2', 'arg3']);
-		});
-	});
-
-	describe('arg and cases support', function() {
-		test('multiple args and cases', function() {
-			let result = parseCases(`
-            offset:1 something:else
-              =0    {{host} does not give a party.}
-              =1    {{host} invites {guest} to her party.}
-              =2    {{host} invites {guest} and one other person to her party.}
-              other {{host} invites {guest} and # other people to her party.}
-            `);
-
-			expect(result.args).toStrictEqual(['offset:1', 'something:else']);
-			expect(result.cases).toStrictEqual({
-				'=0': '{host} does not give a party.',
-				'=1': '{host} invites {guest} to her party.',
-				'=2': '{host} invites {guest} and one other person to her party.',
-				other: '{host} invites {guest} and # other people to her party.'
-			});
-		});
-	});
-});

package/types/IcuMessageFormatter.d.ts

@@ -1,4 +0,0 @@
-export { default as MessageFormatter } from "./MessageFormatter.js";
-export { default as pluralTypeHandler } from "./pluralTypeHandler.js";
-export { default as selectTypeHandler } from "./selectTypeHandler.js";
-export { findClosingBracket, parseCases, splitFormattedArgument } from "./utilities.js";

package/types/MessageFormatter.d.ts

@@ -1,71 +0,0 @@
-/**
- * @typedef {Record<string,any>} FormatValues
- */
-/**
- * @callback ProcessFunction
- * @param {string} message
- * @param {FormatValues} [values={}]
- * @return {any[]}
- */
-/**
- * @callback TypeHandler
- * @param {any} value
- *   The object which matched the key of the block being processed.
- * @param {string} matches
- *   Any format options associated with the block being processed.
- * @param {string} locale
- *   The locale to use for formatting.
- * @param {FormatValues} values
- *   The object of placeholder data given to the original `format`/`process`
- *   call.
- * @param {ProcessFunction} process
- *   The `process` function itself so that sub-messages can be processed by type
- *   handlers.
- * @return {any | any[]}
- */
-/**
- * The main class for formatting messages.
- *
- * @author Emanuel Rabina
- */
-export default class MessageFormatter {
-    /**
-     * Creates a new formatter that can work using any of the custom type handlers
-     * you register.
-     *
-     * @param {string} locale
-     * @param {Record<string,TypeHandler>} [typeHandlers]
-     *   Optional object where the keys are the names of the types to register,
-     *   their values being the functions that will return a nicely formatted
-     *   string for the data and locale they are given.
-     */
-    constructor(locale: string, typeHandlers?: Record<string, TypeHandler>);
-    locale: string;
-    typeHandlers: Record<string, TypeHandler>;
-    /**
-     * Formats an ICU message syntax string using `values` for placeholder data
-     * and any currently-registered type handlers.
-     *
-     * @type {(message: string, values?: FormatValues) => string}
-     */
-    format: (message: string, values?: FormatValues) => string;
-    /**
-     * Process an ICU message syntax string using `values` for placeholder data
-     * and any currently-registered type handlers.  The result of this method is
-     * an array of the component parts after they have been processed in turn by
-     * their own type handlers.  This raw output is useful for other renderers,
-     * eg: React where components can be used instead of being forced to return
-     * raw strings.
-     *
-     * This method is used by {@link MessageFormatter#format} where it acts as a
-     * string renderer.
-     *
-     * @param {string} message
-     * @param {FormatValues} [values]
-     * @return {any[]}
-     */
-    process(message: string, values?: FormatValues): any[];
-}
-export type FormatValues = Record<string, any>;
-export type ProcessFunction = (message: string, values?: FormatValues) => any[];
-export type TypeHandler = (value: any, matches: string, locale: string, values: FormatValues, process: ProcessFunction) => any | any[];

package/types/pluralTypeHandler.d.ts

@@ -1,15 +0,0 @@
-/**
- * Handler for `plural` statements within ICU message syntax strings.  Returns
- * a formatted string for the branch that closely matches the current value.
- *
- * See https://formatjs.io/docs/core-concepts/icu-syntax#plural-format for more
- * details on how the `plural` statement works.
- *
- * @param {string} value
- * @param {string} matches
- * @param {string} locale
- * @param {Record<string,any>} values
- * @param {(message: string, values?: Record<string,any>) => any[]} process
- * @return {any | any[]}
- */
-export default function pluralTypeHandler(value: string, matches: string, locale: string, values: Record<string, any>, process: (message: string, values?: Record<string, any>) => any[]): any | any[];

package/types/selectTypeHandler.d.ts

@@ -1,15 +0,0 @@
-/**
- * Handler for `select` statements within ICU message syntax strings.  Returns
- * a formatted string for the branch that closely matches the current value.
- *
- * See https://formatjs.io/docs/core-concepts/icu-syntax#select-format for more
- * details on how the `select` statement works.
- *
- * @param {string} value
- * @param {string} matches
- * @param {string} locale
- * @param {Record<string,any>} values
- * @param {(message: string, values?: Record<string,any>) => any[]} process
- * @return {any | any[]}
- */
-export default function selectTypeHandler(value: string, matches: string, locale: string, values: Record<string, any>, process: (message: string, values?: Record<string, any>) => any[]): any | any[];

package/types/typedefs.d.ts

@@ -1,3 +0,0 @@
-type FormatValues = Record<string, any>;
-type ProcessFunction = (message: string, values?: FormatValues) => any[];
-type TypeHandler = (value: any, matches: string, locale: string, values: FormatValues, process: ProcessFunction) => any | any[];

package/types/utilities.d.ts

@@ -1,52 +0,0 @@
-/**
- * @typedef ParseCasesResult
- * @property {string[]} args
- *   A list of prepended arguments.
- * @property {Record<string,string>} cases
- *   A map of all cases.
- */
-/**
- * Most branch-based type handlers are based around "cases".  For example,
- * `select` and `plural` compare compare a value to "case keys" to choose a
- * subtranslation.
- *
- * This util splits "matches" portions provided to the aforementioned handlers
- * into case strings, and extracts any prepended arguments (for example,
- * `plural` supports an `offset:n` argument used for populating the magic `#`
- * variable).
- *
- * @param {string} string
- * @return {ParseCasesResult}
- */
-export function parseCases(string: string): ParseCasesResult;
-/**
- * Finds the index of the matching closing curly bracket, including through
- * strings that could have nested brackets.
- *
- * @param {string} string
- * @param {number} fromIndex
- * @return {number}
- *   The index of the matching closing bracket, or -1 if no closing bracket
- *   could be found.
- */
-export function findClosingBracket(string: string, fromIndex: number): number;
-/**
- * Split a `{key, type, format}` block into those 3 parts, taking into account
- * nested message syntax that can exist in the `format` part.
- *
- * @param {string} block
- * @return {string[]}
- *   An array with `key`, `type`, and `format` items in that order, if present
- *   in the formatted argument block.
- */
-export function splitFormattedArgument(block: string): string[];
-export type ParseCasesResult = {
-    /**
-     *   A list of prepended arguments.
-     */
-    args: string[];
-    /**
-     *   A map of all cases.
-     */
-    cases: Record<string, string>;
-};