@unicode-utils/core 0.12.0-beta.15

package/dist/line-helpers-DGsVuiW2.d.ts

@@ -0,0 +1,305 @@
+//#region src/line-helpers.d.ts
+/**
+ * Determines if a line is an End-of-File (EOF) marker.
+ *
+ * In Unicode data files, the EOF marker is typically represented
+ * as a line containing only "# EOF".
+ *
+ * @param {string} [line] - The line to check
+ * @returns {boolean} True if the line is an EOF marker, false otherwise
+ *
+ * @example
+ * ```ts
+ * isEOFMarker("# EOF"); // true
+ * isEOFMarker("Some text"); // false
+ * isEOFMarker(); // false
+ * ```
+ */
+declare function isEOFMarker(line?: string): boolean;
+/**
+ * Determines if a line contains a hash boundary pattern.
+ *
+ * A hash boundary is a line containing a pattern like "# ###" (# followed by multiple #).
+ * These patterns are used in Unicode data files to separate different sections of content.
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line contains a hash boundary pattern, false otherwise
+ *
+ * @example
+ * ```ts
+ * isHashBoundary("# #####"); // true
+ * isHashBoundary("# Some text"); // false
+ * isHashBoundary(""); // false
+ * ```
+ */
+declare function isHashBoundary(line: string): boolean;
+/**
+ * Determines if a line contains an equals boundary pattern.
+ *
+ * An equals boundary is a line containing a pattern like "# ===" (# followed by multiple =).
+ * These patterns are used in Unicode data files to separate different sections of content.
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line contains an equals boundary pattern, false otherwise
+ *
+ * @example
+ * ```ts
+ * isEqualsBoundary("# ====="); // true
+ * isEqualsBoundary("# Some text"); // false
+ * isEqualsBoundary(""); // false
+ * ```
+ */
+declare function isEqualsBoundary(line: string): boolean;
+/**
+ * Determines if a line contains a dash boundary pattern.
+ *
+ * A dash boundary is a line containing a pattern like "# ---" (# followed by multiple -).
+ * These patterns are used in Unicode data files to separate different sections of content.
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line contains a dash boundary pattern, false otherwise
+ *
+ * @example
+ * ```ts
+ * isDashBoundary("# -----"); // true
+ * isDashBoundary("# Some text"); // false
+ * isDashBoundary(""); // false
+ * ```
+ */
+declare function isDashBoundary(line: string): boolean;
+/**
+ * Determines if a line is any type of boundary line.
+ *
+ * A boundary line is any line that matches one of the boundary patterns:
+ * hash boundary, equals boundary, or dash boundary. These patterns are used
+ * in Unicode data files to separate different sections of content.
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line is a boundary line, false otherwise
+ *
+ * @example
+ * ```ts
+ * isBoundaryLine("# #####"); // true (hash boundary)
+ * isBoundaryLine("# ====="); // true (equals boundary)
+ * isBoundaryLine("# -----"); // true (dash boundary)
+ * isBoundaryLine("# Some text"); // false
+ * isBoundaryLine(""); // false
+ * ```
+ */
+declare function isBoundaryLine(line: string): boolean;
+type BoundaryStyle = "#" | "=" | "-";
+/**
+ * Extracts the style character from a boundary line.
+ *
+ * This function determines which type of boundary character is used in the line:
+ * '#', '=', or '-'. It checks the line against each boundary pattern and returns
+ * the corresponding character.
+ *
+ * @param {string} line - The boundary line to analyze
+ * @returns {BoundaryStyle} The boundary style character ('#', '=', or '-')
+ * @throws {Error} If the line is not a valid boundary line
+ *
+ * @example
+ * ```ts
+ * getBoundaryLineStyle("# #####"); // returns "#"
+ * getBoundaryLineStyle("# ====="); // returns "="
+ * getBoundaryLineStyle("# -----"); // returns "-"
+ * ```
+ */
+declare function getBoundaryLineStyle(line: string): BoundaryStyle;
+/**
+ * Determines if a line is a comment line.
+ *
+ * A comment line is either a line that starts with "# " or
+ * a line that only contains "#" (possibly with whitespace).
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line is a comment line, false otherwise
+ */
+declare function isCommentLine(line: string): boolean;
+/**
+ * Removes the comment marker ('#') and any following whitespace from a line.
+ *
+ * This function is designed to extract the actual content from comment lines
+ * in Unicode data files by removing the leading '#' character and any whitespace
+ * that follows it.
+ *
+ * @param {string} line - The comment line to trim
+ * @returns {string} The content of the comment line without the comment marker
+ *
+ * @example
+ * ```ts
+ * trimCommentLine("# Some comment"); // returns "Some comment"
+ * trimCommentLine("#\tTabbed comment"); // returns "Tabbed comment"
+ * trimCommentLine(""); // returns ""
+ * ```
+ */
+declare function trimCommentLine(line: string): string;
+/**
+ * Checks if a string line is empty after trimming whitespace.
+ *
+ * @param {string} line - The string to check for emptiness
+ * @returns {boolean} A boolean indicating whether the trimmed line is empty
+ */
+declare function isEmptyLine(line: string): boolean;
+/**
+ * Determines if a line contains data in a Unicode data file.
+ *
+ * A line is considered to contain data if it is neither a comment line
+ * (starting with '#') nor an empty line.
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line contains data, false otherwise
+ *
+ * @example
+ * ```ts
+ * isLineWithData("U+0020;SPACE"); // true
+ * isLineWithData("# Comment line"); // false
+ * isLineWithData(""); // false
+ * ```
+ */
+declare function isLineWithData(line: string): boolean;
+/**
+ * Check if a given line from a Unicode data file is a 'missing' annotation.
+ *
+ * In Unicode data files, lines starting with '# @missing:' indicate
+ * a range of code points that are not assigned.
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line is a missing annotation, false otherwise
+ */
+declare function isMissingAnnotation(line: string): boolean;
+type SpecialTag = "none" | "script" | "code-point";
+interface MissingAnnotation {
+  start: string;
+  end: string;
+  propertyName?: string;
+  defaultPropertyValue: string;
+  /**
+   * The special tag used in the Annotation.
+   *
+   * NOTE:
+   * - "none" no value is defined
+   * - "script" the value equal to the Script property value for this code point
+   * - "code-point" the string representation of the code point value
+   */
+  specialTag?: SpecialTag;
+}
+/**
+ * Parses a line into a MissingAnnotation object.
+ *
+ * This function attempts to extract information from a line that follows the
+ * format of a missing annotation in Unicode data files.
+ *
+ * The format being parsed is:
+ * `# @missing: START..END; DEFAULT_PROP_VALUE_OR_PROPERTY_NAME[; DEFAULT_PROPERTY_VALUE]`
+ *
+ * @param {string} line - The line to parse
+ * @returns {MissingAnnotation | null} A MissingAnnotation object if the line is a valid missing annotation, null otherwise
+ *
+ * @example
+ * ```ts
+ * parseMissingAnnotation("# @missing: 0000..007F; NA")
+ * // -> { start: "0000", end: "007F", defaultPropertyValue: "NA" }
+ *
+ * parseMissingAnnotation("# @missing: 0000..007F; Script; Unknown")
+ * // -> { start: "0000", end: "007F", propertyName: "Script", defaultPropertyValue: "Unknown" }
+ * ```
+ */
+declare function parseMissingAnnotation(line: string): MissingAnnotation | null;
+/**
+ * Attempts to infer the file name from the first line of a Unicode data file.
+ *
+ * This function extracts the file name from the first line of the content,
+ * assuming it's a comment line. It removes any leading '#' characters and whitespace.
+ *
+ * For example:
+ * - From a file with first line "# ArabicShaping-5.0.0.txt", it returns "ArabicShaping"
+ * - From a file with first line "# UnicodeData-5.0.0.txt", it returns "UnicodeData"
+ *
+ * @param {string} line - The first line of the file
+ * @returns {string | undefined} The inferred file name, or undefined if it can't be determined
+ */
+declare function inferFileName(line: string): string | undefined;
+/**
+ * Attempts to infer the version from the first line of a Unicode data file.
+ *
+ * This function extracts the version number from the first line of the content,
+ * assuming it's a comment line. It looks for a pattern like "Name-X.Y.Z.txt"
+ * and extracts the X.Y.Z part as the version.
+ *
+ * For example:
+ * - From a file with first line "# ArabicShaping-5.0.0.txt", it returns "5.0.0"
+ * - From a file with first line "# UnicodeData-14.0.0.txt", it returns "14.0.0"
+ *
+ * @param {string} line - The first line of the file
+ * @returns {string | undefined} The inferred version number, or undefined if it can't be determined
+ */
+declare function inferVersion(line: string): string | undefined;
+interface ParsedFileName {
+  fileName: string;
+  version: string | undefined;
+}
+/**
+ * Parses a line from a Unicode data file to extract the file name and version information.
+ *
+ * This function tries to extract file name and version information from a line that
+ * typically appears at the beginning of Unicode data files. It handles various formats:
+ * - "FileName-1.2.3.txt"
+ * - "FileName-1.2.3"
+ * - "FileName.txt"
+ *
+ * The function also properly handles comment markers at the beginning of the line.
+ *
+ * @param {string} line - The line to parse, typically the first line of a Unicode data file
+ * @returns {ParsedFileName | undefined} An object containing the file name and version if
+ *                                      successfully parsed, or undefined if parsing fails
+ *
+ * @example
+ * ```ts
+ * parseFileNameLine("# UnicodeData-14.0.0.txt");
+ * // Returns { fileName: "UnicodeData", version: "14.0.0" }
+ *
+ * parseFileNameLine("# ArabicShaping.txt");
+ * // Returns { fileName: "ArabicShaping", version: undefined }
+ * ```
+ */
+declare function parseFileNameLine(line: string): ParsedFileName | undefined;
+/**
+ * Determines if a line represents a property definition in Unicode data files.
+ *
+ * In Unicode data files, properties are typically defined in comment lines that
+ * start with "# Property:" followed by the property name.
+ *
+ * @param {string} line - The line to check
+ * @returns {boolean} True if the line is a property definition, false otherwise
+ *
+ * @example
+ * ```ts
+ * isPropertyLine("# Property: Age"); // true
+ * isPropertyLine("# Some other comment"); // false
+ * isPropertyLine(""); // false
+ * ```
+ */
+declare function isPropertyLine(line: string): boolean;
+/**
+ * Extracts the property value from a property definition line in Unicode data files.
+ *
+ * This function parses a line that follows the format '# Property: [PropertyValue]'
+ * and returns the PropertyValue part. It is used internally by isPropertyLine
+ * to parse property definitions in Unicode data files.
+ *
+ * @param {string} line - The line to extract the property value from
+ * @returns {string | undefined} The extracted property value, or undefined if
+ *                              the line is not a valid property definition
+ *
+ * @example
+ * ```ts
+ * getPropertyValue("# Property: Age"); // returns "Age"
+ * getPropertyValue("# Property: "); // returns undefined
+ * getPropertyValue("# Not a property line"); // returns undefined
+ * ```
+ */
+declare function getPropertyValue(line: string): string | undefined;
+//#endregion
+export { isMissingAnnotation as _, getBoundaryLineStyle as a, parseMissingAnnotation as b, inferVersion as c, isDashBoundary as d, isEOFMarker as f, isLineWithData as g, isHashBoundary as h, SpecialTag as i, isBoundaryLine as l, isEqualsBoundary as m, MissingAnnotation as n, getPropertyValue as o, isEmptyLine as p, ParsedFileName as r, inferFileName as s, BoundaryStyle as t, isCommentLine as u, isPropertyLine as v, trimCommentLine as x, parseFileNameLine as y };

package/dist/line-helpers.d.ts

@@ -0,0 +1,2 @@
+import { _ as isMissingAnnotation, a as getBoundaryLineStyle, b as parseMissingAnnotation, c as inferVersion, d as isDashBoundary, f as isEOFMarker, g as isLineWithData, h as isHashBoundary, i as SpecialTag, l as isBoundaryLine, m as isEqualsBoundary, n as MissingAnnotation, o as getPropertyValue, p as isEmptyLine, r as ParsedFileName, s as inferFileName, t as BoundaryStyle, u as isCommentLine, v as isPropertyLine, x as trimCommentLine, y as parseFileNameLine } from "./line-helpers-DGsVuiW2.js";
+export { BoundaryStyle, MissingAnnotation, ParsedFileName, SpecialTag, getBoundaryLineStyle, getPropertyValue, inferFileName, inferVersion, isBoundaryLine, isCommentLine, isDashBoundary, isEOFMarker, isEmptyLine, isEqualsBoundary, isHashBoundary, isLineWithData, isMissingAnnotation, isPropertyLine, parseFileNameLine, parseMissingAnnotation, trimCommentLine };

package/dist/line-helpers.js

@@ -0,0 +1,3 @@
+import { _ as trimCommentLine, a as isBoundaryLine, c as isEOFMarker, d as isHashBoundary, f as isLineWithData, g as parseMissingAnnotation, h as parseFileNameLine, i as inferVersion, l as isEmptyLine, m as isPropertyLine, n as getPropertyValue, o as isCommentLine, p as isMissingAnnotation, r as inferFileName, s as isDashBoundary, t as getBoundaryLineStyle, u as isEqualsBoundary } from "./line-helpers-CYDQ0FnQ.js";
+
+export { getBoundaryLineStyle, getPropertyValue, inferFileName, inferVersion, isBoundaryLine, isCommentLine, isDashBoundary, isEOFMarker, isEmptyLine, isEqualsBoundary, isHashBoundary, isLineWithData, isMissingAnnotation, isPropertyLine, parseFileNameLine, parseMissingAnnotation, trimCommentLine };

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@unicode-utils/core",
+  "version": "0.12.0-beta.15",
+  "description": "Utilities for working with Unicode",
+  "type": "module",
+  "author": {
+    "name": "Lucas Nørgård",
+    "email": "lucasnrgaard@gmail.com",
+    "url": "https://luxass.dev"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/luxass/unicode-utils#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/luxass/unicode-utils.git",
+    "directory": "packages/core"
+  },
+  "bugs": "https://github.com/luxass/unicode-utils/issues",
+  "keywords": [
+    "unicode",
+    "utils"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./constants": "./dist/constants.js",
+    "./datafile": "./dist/datafile.js",
+    "./line-helpers": "./dist/line-helpers.js",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@luxass/utils": "2.7.2",
+    "defu": "6.1.4",
+    "@unicode-utils/metadata": "0.12.0-beta.15"
+  },
+  "devDependencies": {
+    "@luxass/eslint-config": "6.0.1",
+    "@types/node": "24.9.1",
+    "eslint": "9.38.0",
+    "eslint-plugin-format": "1.0.2",
+    "msw": "2.11.6",
+    "publint": "0.3.15",
+    "tsdown": "0.15.11",
+    "tsx": "4.20.6",
+    "typescript": "5.9.3",
+    "vitest-package-exports": "0.1.1",
+    "@unicode-utils-tooling/tsconfig": "1.0.0",
+    "@unicode-utils-tooling/tsdown-config": "1.0.0"
+  },
+  "scripts": {
+    "build": "tsdown --tsconfig=./tsconfig.build.json",
+    "dev": "tsdown --watch",
+    "test": "vitest --run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}