@fgv/ts-extras 2.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Erik Fortune
+
+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,48 @@
+<div align="center">
+  <h1>ts-utils</h1>
+  Assorted Typescript Utilities
+</div>
+
+<hr/>
+
+## Summary
+
+Assorted less-developed or more specialized odds-and-ends borrowed from one project or another - much less polished and more likely change or disappear:
+* ExtendedArray\<T\> - adds a few useful operations to the built-in Array
+* Formattable\<T\> - simple helpers to create mustache wrappers for objects and make them easily printable
+* Logger - A very basic logger suitable for hobby projects
+* RangeOf\<T\> - Generic open or closed ranges of orderable items (numbers, dates, etc)
+
+---
+
+- [Summary](#summary)
+- [Installation](#installation)
+- [API Documentation](#api-documentation)
+- [Overview](#overview)
+- [API](#api)
+  - [ExtendedArray\<T\>](#extendedarrayt)
+  - [Formattable\<T\>](#formattablet)
+  - [Logger](#logger)
+  - [RangeOf\<T\>](#rangeoft)
+
+## Installation
+
+With npm:
+```sh
+npm install @fgv/ts-extras
+```
+
+## API Documentation
+Extracted API documentation is [here](./docs/ts-extras.md).
+
+## Overview
+
+## API
+
+### ExtendedArray\<T\>
+
+### Formattable\<T\>
+
+### Logger
+
+### RangeOf\<T\>

package/dist/ts-extras.d.ts

@@ -0,0 +1,445 @@
+import { Converter } from '@fgv/ts-utils';
+import { Converters as Converters_2 } from '@fgv/ts-utils';
+import { Result } from '@fgv/ts-utils';
+
+/**
+ * Computes an md5 hash from an array of strings. Not secure and not intended to be secure.
+ * @param parts - The strings to be hashed
+ * @returns An md5 hash of the parts
+ * @public
+ */
+declare function computeHash(parts: string[]): string;
+
+declare namespace Converters {
+    export {
+        extendedArrayOf,
+        rangeTypeOf,
+        rangeOf
+    }
+}
+export { Converters }
+
+declare namespace Csv {
+    export {
+        readCsvFileSync,
+        CsvOptions
+    }
+}
+export { Csv }
+
+/**
+ * Options for {@link Csv.readCsvFileSync}
+ * @beta
+ */
+declare interface CsvOptions {
+    delimiter?: string;
+}
+
+/**
+ * Default {@link Experimental.RangeOfFormats | formats} to use for both
+ * open-ended and complete {@link Experimental.RangeOf | RangeOf<T>}.
+ * @public
+ */
+declare const DEFAULT_RANGEOF_FORMATS: RangeOfFormats;
+
+declare namespace Experimental {
+    export {
+        ExtendedArray,
+        formatList,
+        FormatTargets,
+        Formattable,
+        FormattableBase,
+        Formatter,
+        FormattersByExtendedTarget,
+        FormattersByTarget,
+        RangeOfProperties,
+        RangeOfFormats,
+        DEFAULT_RANGEOF_FORMATS,
+        RangeOf
+    }
+}
+export { Experimental }
+
+/**
+ * An experimental array template which extend built-in `Array` to include a handful
+ * of predicates which return {@link Result | Result<T>}.
+ * @beta
+ */
+declare class ExtendedArray<T> extends Array<T> {
+    readonly itemDescription: string;
+    /**
+     * Constructs an {@link Experimental.ExtendedArray}.
+     * @param itemDescription - Brief description of the type of each item in this array.
+     * @param items - The initial contents of the array.
+     */
+    constructor(itemDescription: string, ...items: T[]);
+    /**
+     * Type guard to determine if some arbitrary array is an
+     * {@link Experimental.ExtendedArray}
+     * @param a - The `Array` to be tested.
+     * @returns Returns `true` if `a` is an {@link Experimental.ExtendedArray},
+     * `false` otherwise.
+     */
+    static isExtendedArray<T>(a?: T[]): a is ExtendedArray<T>;
+    /**
+     * Determines if this array contains exactly one element which matches
+     * a supplied predicate.
+     * @param predicate - The predicate function to be applied.
+     * @returns Returns {@link Success | Success<T>} with the single matching
+     * result if exactly one item matches `predicate`.  Returns {@link Failure}
+     * with an error message if there are no matches or more than one match.
+     */
+    single(predicate?: (item: T) => boolean): Result<T>;
+    /**
+     * Returns the first element of an {@link Experimental.ExtendedArray}. Fails with an
+     * error message if the array is empty.
+     * @param failMessage - Optional message to be displayed in the event of failure.
+     * @returns Returns {@link Success | Success<T>} with the value of the first element
+     * in the array, or {@link Failure} with an error message if the array is empty.
+     */
+    first(failMessage?: string): Result<T>;
+    /**
+     * Returns an array containing all elements of an {@link Experimental.ExtendedArray}. Fails with
+     * an error message if the array is empty.
+     * @param failMessage - Optional message to be displayed in the event of failure.
+     * @returns Returns {@link Success | Success<T[]>} with a new (non-extended) `Array`
+     * containing the elements of this array, or {@link Failure} with an error message
+     * if the array is empty.
+     */
+    atLeastOne(failMessage?: string): Result<T[]>;
+    /**
+     * Gets a new (non-extended) `Array` containing all of the elements from this
+     * {@link Experimental.ExtendedArray}.
+     * @returns A new (non-extended) `Array<T>`.
+     */
+    all(): T[];
+}
+
+/**
+ * A helper function to create a {@link Converter} which converts `unknown` to {@link Experimental.ExtendedArray | ExtendedArray<T>}.
+ * @remarks
+ * If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot
+ * be converted.  If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.
+ * @param converter - {@link Converter} used to convert each item in the array
+ * @param ignoreErrors - Specifies treatment of unconvertible elements
+ * @beta
+ */
+declare function extendedArrayOf<T, TC = undefined>(label: string, converter: Converter<T, TC>, onError?: Converters_2.OnError): Converter<ExtendedArray<T>, TC>;
+
+/**
+ * Formats a list of items using the supplied template and formatter, one result
+ * per output line.
+ * @param format - A mustache template used to format each item.
+ * @param items - The items to be formatted.
+ * @param itemFormatter - The {@link Experimental.Formatter | Formatter<T>} used to format each item.
+ * @returns The resulting string.
+ * @beta
+ */
+declare function formatList<T>(format: string, items: T[], itemFormatter: Formatter<T>): Result<string>;
+
+/**
+ * Interface for an object that can be formatted.
+ * @beta
+ */
+declare interface Formattable {
+    /**
+     * Formats an object using the supplied mustache template.
+     * @param format - A mustache template used to format the object.
+     * @returns {@link Success} with the resulting string, or {@link Failure}
+         * with an error message if an error occurs.
+         */
+     format(format: string): Result<string>;
+    }
+
+    /**
+     * Base class which adds common formatting.
+     * @beta
+     */
+    declare class FormattableBase {
+        /**
+         * Helper enables derived classes to add named details to a formatted presentation.
+         * @param details - An array of detail description strings.
+         * @param label - Label to use for the new detail.
+         * @param value - Value to use for the new detail.
+         * @internal
+         */
+        protected static _tryAddDetail(details: string[], label: string, value: string | undefined): void;
+        /**
+         * {@inheritdoc Experimental.Formattable.format}
+         */
+        format(template: string): Result<string>;
+    }
+
+    /**
+     * Destination format for some formatted string.
+     * @beta
+     */
+    declare type FormatTargets = 'text' | 'markdown' | 'embed';
+
+    /**
+     * Type definition for a formatting function, which takes a `string` and an
+     * item and returns {@link Result | Result<string>}.
+     * @beta
+     */
+    declare type Formatter<T> = (format: string, item: T) => Result<string>;
+
+    /**
+     * A collection of {@link Experimental.Formatter | formatters} indexed by target name, to enable
+     * different format methods per output target.
+     * @beta
+     */
+    declare type FormattersByExtendedTarget<TFT extends FormatTargets, T> = Record<TFT, Formatter<T>>;
+
+    /**
+     * A collection of {@link Experimental.Formatter | formatters} indexed by the
+     * {@link Experimental.FormatTargets | default supported target formats}.
+     * @beta
+     */
+    declare type FormattersByTarget<T> = FormattersByExtendedTarget<FormatTargets, T>;
+
+    declare namespace Hash {
+        export {
+            computeHash,
+            Normalizer
+        }
+    }
+    export { Hash }
+
+    /**
+     * @public
+     */
+    declare type JarFieldPicker<T extends JarRecord = JarRecord> = (record: T) => (keyof T)[];
+
+    /**
+     * Represents a single record in a JAR file
+     * @public
+     */
+    declare type JarRecord = Record<string, string | string[]>;
+
+    /**
+     * Options for a JAR record parser.
+     * @public
+     */
+    declare interface JarRecordParserOptions {
+        readonly arrayFields?: string[] | JarFieldPicker;
+        readonly fixedContinuationSize?: number;
+    }
+
+    /**
+     * Computes a normalized hash for an arbitrary javascript value.
+     * @public
+     */
+    declare class Normalizer {
+        /**
+         * Computes a normalized md5 hash from an arbitrary supplied object.  Not secure and not
+         * intended to be secure.  Also not fast and not intended to be fast.
+         *
+         * Normalization just sorts Maps, Sets and object keys by hash so that differences in order
+         * do not affect the hash.
+         *
+         * @param from - The arbitrary `unknown` to be hashed.
+         * @returns A normalized md5 hash for the supplied value.
+         */
+        computeHash(from: unknown): Result<string>;
+        /**
+         * Compares two property names from some object being normalized.
+         * @param k1 - First key to be compared.
+         * @param k2 - Second key to be compared.
+         * @returns `1` if `k1` is greater, `-1` if `k2` is greater and
+         * `0` if they are equal.
+         * @internal
+         */
+        protected _compareKeys(k1: unknown, k2: unknown): number;
+        /**
+         * Normalizes an array of object property entries (e.g. as returned by `Object.entries()`).
+         * @remarks
+         * Converts property names (entry key) to string and then sorts as string.
+         * @param entries - The entries to be normalized.
+         * @returns A normalized sorted array of entries.
+         * @internal
+         */
+        protected _normalizeEntries(entries: Iterable<[unknown, unknown]>): [unknown, unknown][];
+        /**
+         * Constructs a normalized string representation of some literal value.
+         * @param from - The literal value to be normalized.
+         * @returns A normalized string representation of the literal.
+         * @internal
+         */
+        protected _normalizeLiteral(from: string | number | bigint | boolean | symbol | undefined | Date | RegExp | null): Result<string>;
+    }
+
+    /**
+     * Reads a record-jar from an array of strings, each of which represents one
+     * line in the source file.
+     * @param lines - the array of strings to be parsed
+     * @param options - Optional parser configuration
+     * @returns a corresponding array of `Record<string, string>`
+     * @public
+     */
+    declare function parseRecordJarLines(lines: string[], options?: JarRecordParserOptions): Result<JarRecord[]>;
+
+    /**
+     * Simple implementation of a possibly open-ended range of some comparable
+     * type `<T>` with test and formatting.
+     * @public
+     */
+    declare class RangeOf<T> implements RangeOfProperties<T> {
+        /**
+         * Minimum extent of the range.
+         */
+        readonly min?: T;
+        /**
+         * Maximum extent of the range.
+         */
+        readonly max?: T;
+        /**
+         * Creates a new {@link Experimental.RangeOf | RangeOf<T>}.
+         * @param min - Optional minimum extent of the range.
+         * @param max - Optional maximum extent of the range.
+         */
+        constructor(min?: T, max?: T);
+        /**
+         * Static constructor for a {@link Experimental.RangeOf | RangeOf<T>}.
+         * @param init - {@link Experimental.RangeOfProperties | Range initializer}.
+         * @returns A new {@link Experimental.RangeOf | RangeOf<T>}.
+         */
+        static createRange<T>(init?: RangeOfProperties<T>): Result<RangeOf<T>>;
+        /**
+         * Gets a formatted description of a {@link Experimental.RangeOfProperties | RangeOfProperties<T>} given an
+         * optional set of formats and 'empty' value to use.
+         * @param range - The {@link Experimental.RangeOfProperties | RangeOfProperties<T>} to be formatted.
+         * @param formats - Optional {@link Experimental.RangeOfFormats | formats} to use. Default is
+         * {@link Experimental.DEFAULT_RANGEOF_FORMATS | DEFAULT_RANGEOF_FORMATS}.
+         * @param emptyValue - Value which represents unbounded minimum or maximum for this range. Default is `undefined`.
+         * @returns A string representation of the range.
+         */
+        static propertiesToString<T>(range: RangeOfProperties<T>, formats?: RangeOfFormats, emptyValue?: T): string | undefined;
+        /**
+         * Default comparison uses javascript built-in comparison.
+         * @param t1 - First value to be compared.
+         * @param t2 - Second value to be compared.
+         * @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
+         * and `'equal'` if `t1` and `t2` are equal.
+         * @internal
+         */
+        protected static _defaultCompare<T>(t1: T, t2: T): 'less' | 'equal' | 'greater';
+        /**
+         * Checks if a supplied value is within this range.
+         * @param t - The value to be tested.
+         * @returns `'included'` if `t` falls within the range, `'less'` if `t` falls
+         * below the minimum extent of the range and `'greater'` if `t` is above the
+         * maximum extent.
+         */
+        check(t: T): 'less' | 'included' | 'greater';
+        /**
+         * Determines if a supplied value is within this range.
+         * @param t - The value to be tested.
+         * @returns Returns `true` if `t` falls within the range, `false` otherwise.
+         */
+        includes(t: T): boolean;
+        /**
+         * Finds the transition value that would bring a supplied value `t` into
+         * range.
+         * @param t - The value to be tested.
+         * @returns The minimum extent of the range if `t` is below the range or
+         * the maximum extent of the range if `t` is above the range.  Returns
+         * `undefined` if `t` already falls within the range.
+         */
+        findTransition(t: T): T | undefined;
+        /**
+         * Formats the minimum and maximum values of this range.
+         * @param format - A format function used to format the values.
+         * @returns A {@link Experimental.RangeOfProperties | RangeOfProperties<string>} containing the
+         * formatted representation of the {@link Experimental.RangeOf.min | minimum} and
+         * {@link Experimental.RangeOf.max | maximum}
+         * extent of the range, or `undefined` for an extent that is not present.
+         */
+        toFormattedProperties(format: (value: T) => string | undefined): RangeOfProperties<string>;
+        /**
+         * Formats this range using the supplied format function.
+         * @param format - Format function used to format minimum and maximum extent values.
+         * @param formats - The {@link Experimental.RangeOfFormats | format strings} used to format the range
+         * (default {@link Experimental.DEFAULT_RANGEOF_FORMATS}).
+         * @returns Returns a formatted representation of this range.
+         */
+        format(format: (value: T) => string | undefined, formats?: RangeOfFormats): string | undefined;
+        /**
+         * Inner compare method can be overridden by a derived class.
+         * @param t1 - First value to compare.
+         * @param t2 - Second value to compare.
+         * @returns `'less'` if `t1` is less than `t2`, `'greater'` if `t1` is larger
+         * and `'equal'` if `t1` and `t2` are equal.
+         * @internal
+         */
+        protected _compare(t1: T, t2: T): 'less' | 'equal' | 'greater';
+    }
+
+    /**
+     * A helper wrapper to construct a {@link Converter} which converts to {@link Experimental.RangeOf | RangeOf<T>}
+     * where `<T>` is some comparable type.
+     * @param converter - {@link Converter} used to convert `min` and `max` extent of the range.
+     * @public
+     */
+    declare function rangeOf<T, TC = unknown>(converter: Converter<T, TC>): Converter<RangeOf<T>, TC>;
+
+    /**
+     * Format strings (in mustache format) to
+     * use for both open-ended and complete
+     * {@link Experimental.RangeOf | RangeOf<T>}.
+     * @public
+     */
+    declare interface RangeOfFormats {
+        minOnly: string;
+        maxOnly: string;
+        minMax: string;
+    }
+
+    /**
+     * Represents a generic range of some comparable type `<T>`.
+     * @public
+     */
+    declare interface RangeOfProperties<T> {
+        readonly min?: T;
+        readonly max?: T;
+    }
+
+    /**
+     * A helper wrapper to construct a {@link Converter} which converts to an arbitrary strongly-typed
+     * range of some comparable type.
+     * @param converter - {@link Converter} used to convert `min` and `max` extent of the range.
+     * @param constructor - Static constructor to instantiate the object.
+     * @public
+     */
+    declare function rangeTypeOf<T, RT extends RangeOf<T>, TC = unknown>(converter: Converter<T, TC>, constructor: (init: RangeOfProperties<T>) => Result<RT>): Converter<RT, TC>;
+
+    /**
+     * Reads a CSV file from a supplied path.
+     * @param srcPath - Source path from which the file is read.
+     * @param options - optional parameters to control the processing
+     * @returns The contents of the file.
+     * @beta
+     */
+    declare function readCsvFileSync(srcPath: string, options?: CsvOptions): Result<unknown>;
+
+    /**
+     * Reads a record-jar file from a supplied path.
+     * @param srcPath - Source path from which the file is read.
+     * @param options - Optional parser configuration
+     * @returns The contents of the file as an array of `Record<string, string>`
+     * @see https://datatracker.ietf.org/doc/html/draft-phillips-record-jar-01
+     * @public
+     */
+    declare function readRecordJarFileSync(srcPath: string, options?: JarRecordParserOptions): Result<JarRecord[]>;
+
+    declare namespace RecordJar {
+        export {
+            parseRecordJarLines,
+            readRecordJarFileSync,
+            JarRecord,
+            JarFieldPicker,
+            JarRecordParserOptions
+        }
+    }
+    export { RecordJar }
+
+    export { }

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.39.1"
+    }
+  ]
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+import * as Csv from './packlets/csv';
+import * as Experimental from './packlets/experimental';
+import * as Hash from './packlets/hash';
+import * as RecordJar from './packlets/record-jar';
+import { Converters } from './packlets/conversion';
+export { Converters, Csv, Experimental, Hash, RecordJar };
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,YAAY,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,KAAK,SAAS,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAEnD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC"}

package/lib/index.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+ * Copyright (c) 2020 Erik Fortune
+ *
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordJar = exports.Hash = exports.Experimental = exports.Csv = exports.Converters = void 0;
+const Csv = __importStar(require("./packlets/csv"));
+exports.Csv = Csv;
+const Experimental = __importStar(require("./packlets/experimental"));
+exports.Experimental = Experimental;
+const Hash = __importStar(require("./packlets/hash"));
+exports.Hash = Hash;
+const RecordJar = __importStar(require("./packlets/record-jar"));
+exports.RecordJar = RecordJar;
+const conversion_1 = require("./packlets/conversion");
+Object.defineProperty(exports, "Converters", { enumerable: true, get: function () { return conversion_1.Converters; } });
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,oDAAsC;AAOjB,kBAAG;AANxB,sEAAwD;AAM9B,oCAAY;AALtC,sDAAwC;AAKA,oBAAI;AAJ5C,iEAAmD;AAIL,8BAAS;AAFvD,sDAAmD;AAE1C,2FAFA,uBAAU,OAEA","sourcesContent":["/*\n * Copyright (c) 2020 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as Csv from './packlets/csv';\nimport * as Experimental from './packlets/experimental';\nimport * as Hash from './packlets/hash';\nimport * as RecordJar from './packlets/record-jar';\n\nimport { Converters } from './packlets/conversion';\n\nexport { Converters, Csv, Experimental, Hash, RecordJar };\n"]}

package/lib/packlets/conversion/converters.d.ts

@@ -0,0 +1,28 @@
+import { Converter, Converters, Result } from '@fgv/ts-utils';
+import { ExtendedArray, RangeOf, RangeOfProperties } from '../experimental';
+/**
+ * A helper function to create a {@link Converter} which converts `unknown` to {@link Experimental.ExtendedArray | ExtendedArray<T>}.
+ * @remarks
+ * If `onError` is `'failOnError'` (default), then the entire conversion fails if any element cannot
+ * be converted.  If `onError` is `'ignoreErrors'`, then failing elements are silently ignored.
+ * @param converter - {@link Converter} used to convert each item in the array
+ * @param ignoreErrors - Specifies treatment of unconvertible elements
+ * @beta
+ */
+export declare function extendedArrayOf<T, TC = undefined>(label: string, converter: Converter<T, TC>, onError?: Converters.OnError): Converter<ExtendedArray<T>, TC>;
+/**
+ * A helper wrapper to construct a {@link Converter} which converts to an arbitrary strongly-typed
+ * range of some comparable type.
+ * @param converter - {@link Converter} used to convert `min` and `max` extent of the range.
+ * @param constructor - Static constructor to instantiate the object.
+ * @public
+ */
+export declare function rangeTypeOf<T, RT extends RangeOf<T>, TC = unknown>(converter: Converter<T, TC>, constructor: (init: RangeOfProperties<T>) => Result<RT>): Converter<RT, TC>;
+/**
+ * A helper wrapper to construct a {@link Converter} which converts to {@link Experimental.RangeOf | RangeOf<T>}
+ * where `<T>` is some comparable type.
+ * @param converter - {@link Converter} used to convert `min` and `max` extent of the range.
+ * @public
+ */
+export declare function rangeOf<T, TC = unknown>(converter: Converter<T, TC>): Converter<RangeOf<T>, TC>;
+//# sourceMappingURL=converters.d.ts.map

package/lib/packlets/conversion/converters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converters.d.ts","sourceRoot":"","sources":["../../../src/packlets/conversion/converters.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAc,SAAS,EAAE,UAAU,EAAE,MAAM,EAAuB,MAAM,eAAe,CAAC;AAC/F,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE5E;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,EAAE,GAAG,SAAS,EAC/C,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAC3B,OAAO,GAAE,UAAU,CAAC,OAAuB,GAC1C,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAIjC;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,SAAS,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,EAChE,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAC3B,WAAW,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,EAAE,CAAC,GACtD,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,CAcnB;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAE/F"}