@fedify/vocab-runtime 2.1.0-dev.592 → 2.1.0-dev.600

package/dist/tests/decimal.test.cjs

@@ -0,0 +1,154 @@
+const require_chunk = require('./chunk-DWy1uDak.cjs');
+require('./docloader-nnrZVFak.cjs');
+require('./request-_M2j5bTc.cjs');
+require('./link-DYNFAdNu.cjs');
+require('./url-DIjOdK8Q.cjs');
+require('./multicodec--6hQ74zI.cjs');
+require('./key-CCPn6TEY.cjs');
+require('./multibase-o_ovPHYJ.cjs');
+require('./langstr-EPh86hXK.cjs');
+const node_assert = require_chunk.__toESM(require("node:assert"));
+const node_test = require_chunk.__toESM(require("node:test"));
+
+//#region src/decimal.ts
+const DECIMAL_PATTERN = /^(\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)$/;
+const XML_SCHEMA_WHITESPACE_PATTERN = /[\t\n\r ]+/g;
+function collapseXmlSchemaWhitespace(value) {
+	return value.replace(XML_SCHEMA_WHITESPACE_PATTERN, " ").trim();
+}
+/**
+* Checks whether a string is a valid `xsd:decimal` lexical form.
+*
+* This predicate checks the lexical form strictly, without applying XML Schema
+* whitespace normalization first.  It is useful as a type guard for values
+* that are already expected to be normalized decimal strings.
+*
+* @param value A candidate `xsd:decimal` lexical form.
+* @returns `true` if the string matches the XML Schema `xsd:decimal` lexical
+*          form, or `false` otherwise.
+* @since 2.1.0
+*/
+function isDecimal(value) {
+	return DECIMAL_PATTERN.test(value);
+}
+/**
+* Checks whether a string can be parsed as an `xsd:decimal` lexical form.
+*
+* Unlike {@link isDecimal}, this predicate first applies the XML Schema
+* `whiteSpace="collapse"` normalization step and then validates the
+* normalized string.  This means values like `" 12.50 "` are parseable even
+* though they are not already normalized decimal literals.
+*
+* @param value A candidate `xsd:decimal` lexical form.
+* @returns `true` if the normalized string matches the XML Schema
+*          `xsd:decimal` lexical form, or `false` otherwise.
+* @since 2.1.0
+*/
+function canParseDecimal(value) {
+	return isDecimal(collapseXmlSchemaWhitespace(value));
+}
+/**
+* Parses a string as an `xsd:decimal` lexical form and returns it as a
+* branded {@link Decimal}.
+*
+* This function validates the input against the XML Schema `xsd:decimal`
+* lexical space after applying the XML Schema `whiteSpace="collapse"`
+* normalization step.  It returns the normalized string without any further
+* canonicalization.
+*
+* @param value A candidate `xsd:decimal` lexical form.
+* @returns The normalized string branded as {@link Decimal}.
+* @throws {TypeError} Thrown when the value is not a valid `xsd:decimal`
+*                     lexical form.
+* @example
+* ```typescript
+* const price = parseDecimal("12.50");
+* ```
+* @example
+* ```typescript
+* const price = parseDecimal(" 12.50 ");
+* console.assert(price === "12.50");
+* ```
+* @example
+* ```typescript
+* try {
+*   parseDecimal("1e3");
+* } catch (error) {
+*   console.assert(error instanceof TypeError);
+* }
+* ```
+* @since 2.1.0
+*/
+function parseDecimal(value) {
+	const normalized = collapseXmlSchemaWhitespace(value);
+	if (!isDecimal(normalized)) throw new TypeError(`${JSON.stringify(value)} is not a valid xsd:decimal lexical form.`);
+	return normalized;
+}
+
+//#endregion
+//#region src/decimal.test.ts
+(0, node_test.test)("parseDecimal() accepts valid xsd:decimal lexical forms", () => {
+	const values = [
+		"-1.23",
+		"12678967.543233",
+		"+100000.00",
+		"210",
+		".5",
+		"5.",
+		"0",
+		"-0.0"
+	];
+	for (const value of values) (0, node_assert.deepStrictEqual)(parseDecimal(value), value);
+});
+(0, node_test.test)("isDecimal() reports valid xsd:decimal lexical forms", () => {
+	(0, node_assert.deepStrictEqual)(isDecimal("12.50"), true);
+	(0, node_assert.deepStrictEqual)(isDecimal(".5"), true);
+	(0, node_assert.deepStrictEqual)(isDecimal("1e3"), false);
+	(0, node_assert.deepStrictEqual)(isDecimal(" 12.50 "), false);
+	(0, node_assert.deepStrictEqual)(isDecimal("	12.50\n"), false);
+});
+(0, node_test.test)("canParseDecimal() accepts whitespace-normalized xsd:decimal strings", () => {
+	(0, node_assert.deepStrictEqual)(canParseDecimal("12.50"), true);
+	(0, node_assert.deepStrictEqual)(canParseDecimal(" 12.50 "), true);
+	(0, node_assert.deepStrictEqual)(canParseDecimal("	+100000.00\r\n"), true);
+	(0, node_assert.deepStrictEqual)(canParseDecimal("  .5  "), true);
+	(0, node_assert.deepStrictEqual)(canParseDecimal("1e3"), false);
+	(0, node_assert.deepStrictEqual)(canParseDecimal("1 2.50"), false);
+	(0, node_assert.deepStrictEqual)(canParseDecimal("1	2.50"), false);
+});
+(0, node_test.test)("parseDecimal() normalizes XML Schema whitespace", () => {
+	(0, node_assert.deepStrictEqual)(parseDecimal("12.50"), "12.50");
+	(0, node_assert.deepStrictEqual)(parseDecimal(" 12.50 "), "12.50");
+	(0, node_assert.deepStrictEqual)(parseDecimal("	+100000.00\r\n"), "+100000.00");
+	(0, node_assert.deepStrictEqual)(parseDecimal("  .5  "), ".5");
+});
+(0, node_test.test)("parseDecimal() rejects invalid xsd:decimal lexical forms", () => {
+	const values = [
+		"",
+		".",
+		"+",
+		"-",
+		"1e3",
+		"NaN",
+		"INF",
+		"1,2",
+		"1..2",
+		"1 2.3",
+		"1	2.3"
+	];
+	for (const value of values) (0, node_assert.throws)(() => parseDecimal(value), {
+		name: "TypeError",
+		message: `${JSON.stringify(value)} is not a valid xsd:decimal lexical form.`
+	});
+});
+(0, node_test.test)("parseDecimal() is exported from the package root", () => {
+	(0, node_assert.deepStrictEqual)(parseDecimal("12.50"), "12.50");
+});
+(0, node_test.test)("canParseDecimal() is exported from the package root", () => {
+	(0, node_assert.deepStrictEqual)(canParseDecimal(" 12.50 "), true);
+});
+(0, node_test.test)("isDecimal() is exported from the package root", () => {
+	(0, node_assert.deepStrictEqual)(isDecimal("12.50"), true);
+});
+
+//#endregion

package/dist/tests/decimal.test.d.cts

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

package/dist/tests/decimal.test.d.ts

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

package/dist/tests/decimal.test.js

@@ -0,0 +1,153 @@
+import "./docloader-jdqVG3g0.js";
+import "./request-BmHXdzZg.js";
+import "./link-C3q2TC2G.js";
+import "./url-CWEP9Zs9.js";
+import "./multicodec-Dq3IiOV4.js";
+import "./key-ByCmSI2y.js";
+import "./multibase-B4g8pz6F.js";
+import "./langstr-BsVE3s9u.js";
+import { deepStrictEqual, throws } from "node:assert";
+import { test } from "node:test";
+
+//#region src/decimal.ts
+const DECIMAL_PATTERN = /^(\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)$/;
+const XML_SCHEMA_WHITESPACE_PATTERN = /[\t\n\r ]+/g;
+function collapseXmlSchemaWhitespace(value) {
+	return value.replace(XML_SCHEMA_WHITESPACE_PATTERN, " ").trim();
+}
+/**
+* Checks whether a string is a valid `xsd:decimal` lexical form.
+*
+* This predicate checks the lexical form strictly, without applying XML Schema
+* whitespace normalization first.  It is useful as a type guard for values
+* that are already expected to be normalized decimal strings.
+*
+* @param value A candidate `xsd:decimal` lexical form.
+* @returns `true` if the string matches the XML Schema `xsd:decimal` lexical
+*          form, or `false` otherwise.
+* @since 2.1.0
+*/
+function isDecimal(value) {
+	return DECIMAL_PATTERN.test(value);
+}
+/**
+* Checks whether a string can be parsed as an `xsd:decimal` lexical form.
+*
+* Unlike {@link isDecimal}, this predicate first applies the XML Schema
+* `whiteSpace="collapse"` normalization step and then validates the
+* normalized string.  This means values like `" 12.50 "` are parseable even
+* though they are not already normalized decimal literals.
+*
+* @param value A candidate `xsd:decimal` lexical form.
+* @returns `true` if the normalized string matches the XML Schema
+*          `xsd:decimal` lexical form, or `false` otherwise.
+* @since 2.1.0
+*/
+function canParseDecimal(value) {
+	return isDecimal(collapseXmlSchemaWhitespace(value));
+}
+/**
+* Parses a string as an `xsd:decimal` lexical form and returns it as a
+* branded {@link Decimal}.
+*
+* This function validates the input against the XML Schema `xsd:decimal`
+* lexical space after applying the XML Schema `whiteSpace="collapse"`
+* normalization step.  It returns the normalized string without any further
+* canonicalization.
+*
+* @param value A candidate `xsd:decimal` lexical form.
+* @returns The normalized string branded as {@link Decimal}.
+* @throws {TypeError} Thrown when the value is not a valid `xsd:decimal`
+*                     lexical form.
+* @example
+* ```typescript
+* const price = parseDecimal("12.50");
+* ```
+* @example
+* ```typescript
+* const price = parseDecimal(" 12.50 ");
+* console.assert(price === "12.50");
+* ```
+* @example
+* ```typescript
+* try {
+*   parseDecimal("1e3");
+* } catch (error) {
+*   console.assert(error instanceof TypeError);
+* }
+* ```
+* @since 2.1.0
+*/
+function parseDecimal(value) {
+	const normalized = collapseXmlSchemaWhitespace(value);
+	if (!isDecimal(normalized)) throw new TypeError(`${JSON.stringify(value)} is not a valid xsd:decimal lexical form.`);
+	return normalized;
+}
+
+//#endregion
+//#region src/decimal.test.ts
+test("parseDecimal() accepts valid xsd:decimal lexical forms", () => {
+	const values = [
+		"-1.23",
+		"12678967.543233",
+		"+100000.00",
+		"210",
+		".5",
+		"5.",
+		"0",
+		"-0.0"
+	];
+	for (const value of values) deepStrictEqual(parseDecimal(value), value);
+});
+test("isDecimal() reports valid xsd:decimal lexical forms", () => {
+	deepStrictEqual(isDecimal("12.50"), true);
+	deepStrictEqual(isDecimal(".5"), true);
+	deepStrictEqual(isDecimal("1e3"), false);
+	deepStrictEqual(isDecimal(" 12.50 "), false);
+	deepStrictEqual(isDecimal("	12.50\n"), false);
+});
+test("canParseDecimal() accepts whitespace-normalized xsd:decimal strings", () => {
+	deepStrictEqual(canParseDecimal("12.50"), true);
+	deepStrictEqual(canParseDecimal(" 12.50 "), true);
+	deepStrictEqual(canParseDecimal("	+100000.00\r\n"), true);
+	deepStrictEqual(canParseDecimal("  .5  "), true);
+	deepStrictEqual(canParseDecimal("1e3"), false);
+	deepStrictEqual(canParseDecimal("1 2.50"), false);
+	deepStrictEqual(canParseDecimal("1	2.50"), false);
+});
+test("parseDecimal() normalizes XML Schema whitespace", () => {
+	deepStrictEqual(parseDecimal("12.50"), "12.50");
+	deepStrictEqual(parseDecimal(" 12.50 "), "12.50");
+	deepStrictEqual(parseDecimal("	+100000.00\r\n"), "+100000.00");
+	deepStrictEqual(parseDecimal("  .5  "), ".5");
+});
+test("parseDecimal() rejects invalid xsd:decimal lexical forms", () => {
+	const values = [
+		"",
+		".",
+		"+",
+		"-",
+		"1e3",
+		"NaN",
+		"INF",
+		"1,2",
+		"1..2",
+		"1 2.3",
+		"1	2.3"
+	];
+	for (const value of values) throws(() => parseDecimal(value), {
+		name: "TypeError",
+		message: `${JSON.stringify(value)} is not a valid xsd:decimal lexical form.`
+	});
+});
+test("parseDecimal() is exported from the package root", () => {
+	deepStrictEqual(parseDecimal("12.50"), "12.50");
+});
+test("canParseDecimal() is exported from the package root", () => {
+	deepStrictEqual(canParseDecimal(" 12.50 "), true);
+});
+test("isDecimal() is exported from the package root", () => {
+	deepStrictEqual(isDecimal("12.50"), true);
+});
+
+//#endregion