@sushichan044/kg-core 0.6.5 → 0.8.0

package/dist/plugin.d.mts

@@ -0,0 +1,3 @@
+import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, r as NamespacedId } from "./composed-manuscript-QgIdae8p.mjs";
+import { a as InlineMeasureRequest, c as logicalInlineMeasurer, f as ManuscriptComposer, m as Rejection, n as createNovelComposer, o as InlineMeasurement, p as ManuscriptParser, s as InlineMeasurer } from "./novel-composer-BCt9g172.mjs";
+export { type InlineMeasureRequest, type InlineMeasurement, type InlineMeasurer, type ManuscriptComposer, type ManuscriptParser, ManuscriptResult, NamespacedId, ParsedManuscript, type Rejection, ValidationIssue, createNovelComposer, logicalInlineMeasurer };

package/dist/plugin.mjs

@@ -0,0 +1,3 @@
+import { c as ManuscriptResult, d as NamespacedId, s as ValidationIssue } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
+import { a as logicalInlineMeasurer, p as ParsedManuscript, t as createNovelComposer } from "./novel-composer-CROZLBqt.mjs";
+export { ManuscriptResult, NamespacedId, ParsedManuscript, ValidationIssue, createNovelComposer, logicalInlineMeasurer };

package/dist/question-or-exclamation-spacing-B5o23ZLf.mjs

@@ -0,0 +1,251 @@
+import * as v from "valibot";
+//#region src/internal/schema.ts
+/**
+* Every DTO in this package is a closed, frozen object: unknown keys are rejected, output is
+* readonly.
+*/
+const readonlyObject = (entries) => v.pipe(v.strictObject(entries), v.readonly());
+const readonlyArray = (item) => v.pipe(v.array(item), v.readonly());
+const nonNegativeInteger = (maximum = Number.POSITIVE_INFINITY) => v.pipe(v.number(), v.finite(), v.integer(), v.minValue(0), v.maxValue(maximum));
+const positiveInteger = () => v.pipe(v.number(), v.finite(), v.integer(), v.minValue(1));
+const TextRange = { schema: v.pipe(readonlyObject({
+	start: nonNegativeInteger(),
+	end: nonNegativeInteger()
+}), v.check(({ start, end }) => end >= start, "range end must not precede its start")) };
+const DisplayRange = { schema: v.pipe(TextRange.schema, v.brand("DisplayRange")) };
+const GraphemeRange = { schema: v.pipe(TextRange.schema, v.brand("GraphemeRange")) };
+//#endregion
+//#region src/range/manuscript-range.ts
+const ManuscriptRangeSchema = readonlyObject({
+	source: { schema: v.pipe(TextRange.schema, v.brand("SourceRange")) }.schema,
+	display: DisplayRange.schema,
+	graphemes: GraphemeRange.schema
+});
+const ManuscriptRange = {
+	schema: ManuscriptRangeSchema,
+	/**
+	* Brands a span core computed itself. Throws rather than returning a failure: the inputs come
+	* from core's own arithmetic, so a violated bound is a bug here, not bad data from a caller.
+	*/
+	of: (input) => v.parse(ManuscriptRangeSchema, input),
+	merge: (ranges) => {
+		const present = ranges.filter((range) => range !== null);
+		if (present.length === 0) return null;
+		return ManuscriptRange.of({
+			source: {
+				start: Math.min(...present.map(({ source }) => source.start)),
+				end: Math.max(...present.map(({ source }) => source.end))
+			},
+			display: {
+				start: Math.min(...present.map(({ display }) => display.start)),
+				end: Math.max(...present.map(({ display }) => display.end))
+			},
+			graphemes: {
+				start: Math.min(...present.map(({ graphemes }) => graphemes.start)),
+				end: Math.max(...present.map(({ graphemes }) => graphemes.end))
+			}
+		});
+	},
+	overlaps: (range, other) => range.graphemes.start < other.graphemes.end && range.graphemes.end > other.graphemes.start
+};
+const SourcePosition = {
+	schema: readonlyObject({
+		offset: nonNegativeInteger(),
+		line: positiveInteger(),
+		column: positiveInteger()
+	}),
+	/**
+	* Counts CRLF, CR and LF as one line break each; column is UTF-16 code units from line start.
+	*/
+	at: (source, offset) => {
+		let line = 1;
+		let lineStart = 0;
+		let index = 0;
+		while (index < offset) if (source[index] === "\r") {
+			index += source[index + 1] === "\n" ? 2 : 1;
+			line += 1;
+			lineStart = index;
+		} else if (source[index] === "\n") {
+			index += 1;
+			line += 1;
+			lineStart = index;
+		} else index += 1;
+		return {
+			offset,
+			line,
+			column: offset - lineStart + 1
+		};
+	}
+};
+//#endregion
+//#region src/namespaced-id.ts
+const NamespacedIdSchema = v.pipe(v.string(), v.nonEmpty(), v.regex(/^[^/]+\/[^/]+$/u, "ID must use namespace/name"), v.brand("NamespacedId"));
+const NamespacedId = {
+	schema: NamespacedIdSchema,
+	/**
+	* For IDs written as literals in code. Throws on a malformed literal, at import time.
+	*/
+	of: (literal) => v.parse(NamespacedIdSchema, literal),
+	/**
+	* For IDs supplied by a plugin, where a malformed value is bad input rather than a bug.
+	*/
+	parse: (raw) => {
+		const result = v.safeParse(NamespacedIdSchema, raw);
+		return result.success ? result.output : void 0;
+	}
+};
+const DiagnosticOrigin = { schema: v.variant("kind", [readonlyObject({
+	kind: v.literal("parser"),
+	id: NamespacedId.schema
+}), readonlyObject({
+	kind: v.literal("rule"),
+	id: NamespacedId.schema
+})]) };
+const DiagnosticSeverity = { schema: v.picklist(["warning", "error"]) };
+const ManuscriptDiagnostic = {
+	schema: readonlyObject({
+		id: v.string(),
+		origin: DiagnosticOrigin.schema,
+		severity: DiagnosticSeverity.schema,
+		message: v.string(),
+		range: ManuscriptRange.schema,
+		location: readonlyObject({
+			start: SourcePosition.schema,
+			end: SourcePosition.schema
+		})
+	}),
+	of: ({ source, origin, severity, code, message, range }) => ({
+		id: `${origin.kind}:${origin.id}:${code}:${range.source.start}:${range.source.end}`,
+		origin,
+		severity,
+		message,
+		range,
+		location: {
+			start: SourcePosition.at(source, range.source.start),
+			end: SourcePosition.at(source, range.source.end)
+		}
+	}),
+	/**
+	* Stable order for display: by source span, then by producing plugin.
+	*/
+	compare: (left, right) => left.range.source.start - right.range.source.start || left.range.source.end - right.range.source.end || left.origin.id.localeCompare(right.origin.id)
+};
+//#endregion
+//#region src/result/manuscript-result.ts
+const ManuscriptResult = {
+	succeed: (value, warnings = []) => ({
+		ok: true,
+		value,
+		warnings
+	}),
+	fail: (error) => ({
+		ok: false,
+		error
+	}),
+	/**
+	* Validates a result that crossed a plugin boundary, including the diagnostics it carries.
+	*/
+	schema: (value, error) => v.variant("ok", [readonlyObject({
+		ok: v.literal(true),
+		value,
+		warnings: readonlyArray(ManuscriptDiagnostic.schema)
+	}), readonlyObject({
+		ok: v.literal(false),
+		error
+	})])
+};
+const ValidationIssue = {
+	schema: readonlyObject({
+		path: v.string(),
+		message: v.string()
+	}),
+	from: (issues) => issues.map((issue) => ({
+		path: (issue.path ?? []).map((item) => String(item.key)).join("."),
+		message: issue.message
+	}))
+};
+//#endregion
+//#region src/internal/segmenter.ts
+/**
+* Shared across parsing and proofreading so both agree on what counts as one grapheme.
+*/
+const graphemeSegmenter = new Intl.Segmenter("ja", { granularity: "grapheme" });
+//#endregion
+//#region src/internal/japanese-brackets.ts
+/**
+* Brackets and quotes a Japanese paragraph may open with. Halfwidth forms are included because a
+* manuscript that uses them is still opening a paragraph, not writing prose.
+*/
+const OPENING_BRACKETS = "「『〖〈《（(“\"‘'［[〔｛{＜<";
+/**
+* The closing counterparts, in the same order.
+*/
+const CLOSING_BRACKETS = "」』〗〉》）)”\"’'］]〕｝}＞>";
+/**
+* Escapes the characters a regular expression character class would otherwise read as syntax, so a
+* set declared above can be dropped into a pattern.
+*/
+function characterClass(characters) {
+	return characters.replaceAll(/[\\\]^-]/gu, "\\$&");
+}
+//#endregion
+//#region src/internal/japanese-spaces.ts
+const LEADING_SPACES = /^[　 \t]+/u;
+/**
+* The run of spaces the text begins with, or an empty string. Halfwidth spaces and tabs count: a
+* rule has to see them to say they are the wrong space.
+*/
+function leadingSpaces(text) {
+	return LEADING_SPACES.exec(text)?.[0] ?? "";
+}
+//#endregion
+//#region src/internal/question-or-exclamation-spacing.ts
+/**
+* Runs, not single marks: `！？` is one mark and takes one gap, so the gap belongs after the run.
+*/
+const MARKS = /[？！]+/gu;
+function analyzeMatch(line, marks) {
+	const start = marks.index;
+	if (start === void 0) return void 0;
+	const marksRange = {
+		start,
+		end: start + marks[0].length
+	};
+	const next = line[marksRange.end];
+	if (next === void 0 || "」』〗〉》）)”\"’'］]〕｝}＞>".includes(next)) return void 0;
+	const spaces = leadingSpaces(line.slice(marksRange.end));
+	if (spaces === "") return {
+		kind: "missing",
+		marks: marksRange
+	};
+	const gap = {
+		start: marksRange.end,
+		end: marksRange.end + spaces.length
+	};
+	const following = line[gap.end];
+	if (following !== void 0 && "」』〗〉》）)”\"’'］]〕｝}＞>".includes(following)) return {
+		kind: "before-closing-bracket",
+		marks: marksRange,
+		gap
+	};
+	if (spaces !== "　") return {
+		kind: "invalid-space",
+		marks: marksRange,
+		gap
+	};
+	return {
+		kind: "valid",
+		marks: marksRange,
+		gap
+	};
+}
+/**
+* Classifies the spacing after each run of fullwidth question or exclamation marks in one display
+* line. Runs at the end of the line or immediately before a closing bracket need no gap and are
+* omitted from the result.
+*/
+function questionOrExclamationSpacings(line) {
+	return [...line.matchAll(MARKS)].map((marks) => analyzeMatch(line, marks)).filter((spacing) => spacing !== void 0);
+}
+//#endregion
+export { characterClass as a, ManuscriptResult as c, NamespacedId as d, ManuscriptRange as f, readonlyObject as h, OPENING_BRACKETS as i, ManuscriptDiagnostic as l, readonlyArray as m, leadingSpaces as n, graphemeSegmenter as o, nonNegativeInteger as p, CLOSING_BRACKETS as r, ValidationIssue as s, questionOrExclamationSpacings as t, DiagnosticSeverity as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sushichan044/kg-core",
-  "version": "0.6.5",
+  "version": "0.8.0",
   "description": "Framework-independent parsing, composition, and proofreading for Japanese manuscripts",
   "keywords": [
     "japanese",
@@ -36,6 +36,14 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
     },
+    "./lint": {
+      "types": "./dist/lint.d.mts",
+      "import": "./dist/lint.mjs"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.mts",
+      "import": "./dist/plugin.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -49,10 +57,9 @@
   },
   "devDependencies": {
     "@arethetypeswrong/core": "0.18.5",
-    "publint": "0.3.22",
+    "publint": "0.3.24",
     "typescript": "7.0.2",
-    "unplugin-unused": "0.5.7",
-    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.7",
+    "unplugin-unused": "0.6.0",
     "vite-plus": "0.3.0"
   },
   "engines": {