rules.bytes のオプションに newline を追加

Author: natade-jp

HISTORY.md

@@ -1,8 +1,9 @@
 ### History
 
-#### 1.1.x 2026/x/xx
+#### 1.1.0 2026/x/xx
 
 - `attach` の引数に `onChange` を追加
+- `rules.bytes` のオプションに `newline` を追加
 - `textarea` に対して `attach` を実施した場合に改行できなかった不具合を修正
 - 文字の制御が入らない場合はアンドゥ／リドゥを行える機能を追加
 

docs/api.md

@@ -599,24 +599,27 @@ rules.width({
 #### `bytes()`
 
 入力値の最大サイズ（バイト数）を制御します。単位は `"utf-8" | "utf-16" | "utf-32" | "sjis" | "cp932"` から選べます。
+改行コードの扱いも指定でき、バイト数の計算に反映されます。
 
 **例**
 
 ```js
 rules.bytes({
 	max: 64,
 	mode: "block",
-	unit: "utf-8"
+	unit: "utf-8",
+	newline: "\r\n"
 });
 ```
 
 **オプション**
 
-| option | type                                                   | default   | 説明                                                                                          |
-| ------ | ------------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------- |
-| `max`  | `number`                                               | -         | 最大サイズ（バイト数）。未指定なら制限なし                                                    |
-| `mode` | `"block" \| "error"`                                   | `"block"` | 最大サイズを超えたときの挙動（`block`: 超過分を入力時にカット / `error`: 変更せずエラー扱い） |
-| `unit` | `"utf-8" \| "utf-16" \| "utf-32" \| "sjis" \| "cp932"` | `"utf-8"` | サイズの単位（バイト数の数え方）                                                              |
+| option    | type                                                   | default   | 説明                                                                                          |
+| --------- | ------------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------- |
+| `max`     | `number`                                               | -         | 最大サイズ（バイト数）。未指定なら制限なし                                                    |
+| `mode`    | `"block" \| "error"`                                   | `"block"` | 最大サイズを超えたときの挙動（`block`: 超過分を入力時にカット / `error`: 変更せずエラー扱い） |
+| `unit`    | `"utf-8" \| "utf-16" \| "utf-32" \| "sjis" \| "cp932"` | `"utf-8"` | サイズの単位（バイト数の数え方）                                                              |
+| `newline` | `"\n" \| "\r" \| "\r\n"`                               | `"\n"`    | 改行コードの扱い。内部で改行は正規化され、指定した改行コードとしてバイト数が計算される        |
 
 **補足**
 
@@ -625,8 +628,8 @@ rules.bytes({
 - `"utf-32"`: コードポイント数 × 4（例：`"é"` は 8 bytes）
 - `"sjis"` / `"cp932"`: Shift_JIS（Windows-31J 系）にエンコードしたときのバイト数
     - 「旧Windows互換」「Shift_JIS 前提の外部I/F」などに合わせる用途です。エンコード不能になるので、 `filter()`（`"sjis-only"` / `"cp932-only"` など）とセットで使用してください。
-
-※ ライブラリ内部では Shift_JIS で算出します（sjis/cp932 の差異はフィルタ側の許可範囲で制御する想定）
+    - ライブラリ内部では Shift_JIS で算出します（sjis/cp932 の差異はフィルタ側の許可範囲で制御する想定）
+- 入力中の改行コード（`\r\n`, `\r`, `\n`）は内部で一度 `\n` へ正規化後に計算を行います
 
 **運用上の注意**
 

examples/dev/textarea.js

@@ -18,6 +18,12 @@ const guard = attach(input, {
 			max: 10,
 			mode: "block",
 			unit: "grapheme"
+		}),
+		rules.bytes({
+			max: 5,
+			mode: "block",
+			unit: "sjis",
+			newline: "\r\n"
 		})
 	],
 	onChange: (guard) => {

package-lock.json

@@ -1,6 +1,6 @@
 {
 	"name": "text-input-guard",
-	"version": "1.0.2",
+	"version": "1.1.0",
 	"description": "A JavaScript input guard library for Japanese web apps, handling full-width digits, numeric rules, digit limits, and formatted display.",
 	"keywords": ["input-validation",
 		"numeric-input",

package.json

@@ -14,9 +14,10 @@ import { parseDatasetNumber, parseDatasetEnum } from "./_dataset.js";
 /**
  * bytes ルールのオプション
  * @typedef {Object} BytesRuleOptions
- * @property {number} [max] - 最大長（グラフェム数）。未指定なら制限なし
+ * @property {number} [max] - バイト数。未指定なら制限なし
  * @property {"block"|"error"} [mode="block"] - 入力中に最大長を超えたときの挙動
  * @property {"utf-8"|"utf-16"|"utf-32"|"sjis"|"cp932"} [unit="utf-8"] - サイズの単位(sjis系を使用する場合はfilterも必須)
+ * @property {"\n"|"\r"|"\r\n"} [newline="\n"] - 改行の扱い(バイト数計算に影響あり)
  */
 
 /**
@@ -25,25 +26,28 @@ import { parseDatasetNumber, parseDatasetEnum } from "./_dataset.js";
  */
 
 /**
- * グラフェム/UTF-16コード単位/UTF-32コード単位の長さを調べる
+ * テキストのバイト数を調べる
  * @param {string} text
  * @param {"utf-8"|"utf-16"|"utf-32"|"sjis"|"cp932"} unit
+ * @param {"\n"|"\r"|"\r\n"} newline
  * @returns {number}
  */
-const getTextBytesByUnit = function(text, unit) {
+const getTextBytesByUnit = function(text, unit, newline) {
 	if (text.length === 0) {
 		return 0;
 	}
+
+	const normalizedText = text.replace(/\r?\n/g, newline);
+
 	if (unit === "utf-8") {
-		return Mojix.toUTF8Array(text).length;
+		return Mojix.toUTF8Array(normalizedText).length;
 	} else if (unit === "utf-16") {
-		return Mojix.toUTF16Array(text).length * 2;
+		return Mojix.toUTF16Array(normalizedText).length * 2;
 	} else if (unit === "utf-32") {
-		return Mojix.toUTF32Array(text).length * 4;
+		return Mojix.toUTF32Array(normalizedText).length * 4;
 	} else if (unit === "sjis" || unit === "cp932") {
-		return Mojix.encode(text, "Shift_JIS").length;
+		return Mojix.encode(normalizedText, "Shift_JIS").length;
 	} else {
-		// ここには来ない
 		throw new Error(`Invalid unit: ${unit}`);
 	}
 };
@@ -53,9 +57,10 @@ const getTextBytesByUnit = function(text, unit) {
  * @param {string} text
  * @param {"utf-8"|"utf-16"|"utf-32"|"sjis"|"cp932"} unit
  * @param {number} max
+ * @param {"\n"|"\r"|"\r\n"} newline
  * @returns {string}
  */
-const cutTextByUnit = function(text, unit, max) {
+const cutTextByUnit = function(text, unit, max, newline) {
 	/**
 	 * グラフェムの配列
 	 * @type {Grapheme[]}
@@ -74,19 +79,10 @@ const cutTextByUnit = function(text, unit, max) {
 	const outputGraphemeArray = [];
 
 	for (let i = 0; i < graphemeArray.length; i++) {
-		const g = graphemeArray[i];
-
 		// 1グラフェムあたりの長さ
-		let byteCount = 0;
-		if (unit === "utf-8") {
-			byteCount = Mojix.toUTF8Array(Mojix.toStringFromMojiArray([g])).length;
-		} else if (unit === "utf-16") {
-			byteCount = Mojix.toUTF16Array(Mojix.toStringFromMojiArray([g])).length * 2;
-		} else if (unit === "utf-32") {
-			byteCount = Mojix.toUTF32Array(Mojix.toStringFromMojiArray([g])).length * 4;
-		} else if (unit === "sjis" || unit === "cp932") {
-			byteCount = Mojix.encode(Mojix.toStringFromMojiArray([g]), "Shift_JIS").length;
-		}
+		const g = graphemeArray[i];
+		const gText = Mojix.toStringFromMojiArray([g]);
+		const byteCount = getTextBytesByUnit(gText, unit, newline);
 
 		if (count + byteCount > max) {
 			// 空配列を渡すとNUL文字を返すため、空配列のときは空文字を返す
@@ -111,15 +107,16 @@ const cutTextByUnit = function(text, unit, max) {
  * @param {string} insertedText 追加するテキスト
  * @param {"utf-8"|"utf-16"|"utf-32"|"sjis"|"cp932"} unit
  * @param {number} max
+ * @param {"\n"|"\r"|"\r\n"} newline
  * @returns {string} 追加するテキストを切ったもの（切る必要がない場合は insertedText をそのまま返す）
  */
-const cutBytes = function(beforeText, insertedText, unit, max) {
-	const beforeTextLen = getTextBytesByUnit(beforeText, unit);
+const cutBytes = function(beforeText, insertedText, unit, max, newline) {
+	const beforeTextLen = getTextBytesByUnit(beforeText, unit, newline);
 
 	// すでに最大長を超えている場合は追加のテキストを全て切る
 	if (beforeTextLen >= max) { return ""; }
 
-	const insertedTextLen = getTextBytesByUnit(insertedText, unit);
+	const insertedTextLen = getTextBytesByUnit(insertedText, unit, newline);
 	const totalLen = beforeTextLen + insertedTextLen;
 
 	if (totalLen <= max) {
@@ -129,7 +126,7 @@ const cutBytes = function(beforeText, insertedText, unit, max) {
 
 	// 超える場合は追加のテキストを切る
 	const allowedAddLen = max - beforeTextLen;
-	return cutTextByUnit(insertedText, unit, allowedAddLen);
+	return cutTextByUnit(insertedText, unit, allowedAddLen, newline);
 };
 
 /**
@@ -138,48 +135,46 @@ const cutBytes = function(beforeText, insertedText, unit, max) {
  * @returns {import("../text-input-guard.js").Rule}
  */
 export function bytes(options = {}) {
-	/** @type {BytesRuleOptions} */
-	const opt = {
-		max: typeof options.max === "number" ? options.max : undefined,
-		mode: options.mode ?? "block",
-		unit: options.unit ?? "utf-8"
-	};
+	const max = typeof options.max === "number" ? options.max : undefined;
+	const mode = options.mode ?? "block";
+	const unit = options.unit ?? "utf-8";
+	const newline = options.newline ?? "\n";
 
 	return {
 		name: "bytes",
 		targets: ["input", "textarea"],
 
 		normalizeChar(value, ctx) {
 			// block 以外は何もしない
-			if (opt.mode !== "block") {
+			if (mode !== "block") {
 				return value;
 			}
 			// max 未指定なら制限なし
-			if (typeof opt.max !== "number") {
+			if (typeof max !== "number") {
 				return value;
 			}
 
-			const cutText = cutBytes(ctx.beforeText, value, opt.unit, opt.max);
+			const cutText = cutBytes(ctx.beforeText, value, unit, max, newline);
 			return cutText;
 		},
 
 		validate(value, ctx) {
 			// error 以外は何もしない
-			if (opt.mode !== "error") {
+			if (mode !== "error") {
 				return;
 			}
 			// max 未指定なら制限なし
-			if (typeof opt.max !== "number") {
+			if (typeof max !== "number") {
 				return;
 			}
 
-			const len = getTextBytesByUnit(value, opt.unit);
-			if (len > opt.max) {
+			const len = getTextBytesByUnit(value, unit, newline);
+			if (len > max) {
 				ctx.pushError({
 					code: "bytes.max_overflow",
 					rule: "bytes",
 					phase: "validate",
-					detail: { limit: opt.max, actual: len }
+					detail: { limit: max, actual: len }
 				});
 			}
 		}
@@ -196,6 +191,7 @@ export function bytes(options = {}) {
  * - data-tig-rules-bytes-max                 -> dataset.tigRulesBytesMax
  * - data-tig-rules-bytes-mode                -> dataset.tigRulesBytesMode
  * - data-tig-rules-bytes-unit                -> dataset.tigRulesBytesUnit
+ * - data-tig-rules-bytes-newline             -> dataset.tigRulesBytesNewline
  *
  * @param {DOMStringMap} dataset
  * @param {HTMLInputElement|HTMLTextAreaElement} _el
@@ -228,5 +224,13 @@ bytes.fromDataset = function fromDataset(dataset, _el) {
 		options.unit = unit;
 	}
 
+	const newline = parseDatasetEnum(
+		dataset.tigRulesBytesNewline,
+		["\n", "\r", "\r\n"]
+	);
+	if (newline != null) {
+		options.newline = newline;
+	}
+
 	return bytes(options);
 };

src/rules/bytes.js

@@ -237,3 +237,70 @@ test("bytes - fromDataset: unit が不正（未対応値）なら default(utf-8)
 	assert.equal(errs.length, 1);
 	assert.deepEqual(errs[0].detail, { limit: 4, actual: 5 });
 });
+
+test("bytes - newline: LF(\\n) を1バイトとして扱う（utf-8）", () => {
+	const rule = bytes({ max: 3, mode: "block", unit: "utf-8", newline: "\n" });
+
+	const ctx = makeCtx({
+		beforeText: "",
+		insertedText: "a\nb" // a(1) + \n(1) + b(1) = 3
+	});
+
+	const out = rule.normalizeChar("a\nb", ctx);
+
+	assert.equal(out, "a\nb");
+});
+
+test("bytes - newline: CRLF(\\r\\n) を2バイトとして扱う（utf-8）", () => {
+	const rule = bytes({ max: 3, mode: "block", unit: "utf-8", newline: "\r\n" });
+
+	const ctx = makeCtx({
+		beforeText: "",
+		insertedText: "a\nb" // a(1) + \r\n(2) + b(1) = 4 > 3
+	});
+
+	const out = rule.normalizeChar("a\nb", ctx);
+
+	// "a\n" まで入る想定（= a + 改行）
+	assert.equal(out, "a\n");
+});
+
+test("bytes - newline: CR(\\r) を1バイトとして扱う（utf-8）", () => {
+	const rule = bytes({ max: 2, mode: "block", unit: "utf-8", newline: "\r" });
+
+	const ctx = makeCtx({
+		beforeText: "",
+		insertedText: "\n\n" // 改行2つ → 1byte×2 = 2
+	});
+
+	const out = rule.normalizeChar("\n\n", ctx);
+
+	assert.equal(out, "\n\n");
+});
+
+test("bytes - newline: 入力に CRLF が混在しても正規化してカウントされる", () => {
+	const rule = bytes({ max: 3, mode: "block", unit: "utf-8", newline: "\n" });
+
+	const ctx = makeCtx({
+		beforeText: "",
+		insertedText: "a\r\nb"
+	});
+
+	const out = rule.normalizeChar("a\r\nb", ctx);
+
+	// a(1) + \n(1) + b(1) = 3
+	assert.equal(out, "a\r\nb");
+});
+
+test("bytes - newline: validate でも改行が指定コードで計算される", () => {
+	const rule = bytes({ max: 3, mode: "error", unit: "utf-8", newline: "\r\n" });
+
+	const ctx = makeCtx();
+
+	// a(1) + \r\n(2) + b(1) = 4 > 3
+	rule.validate("a\nb", ctx);
+
+	const errs = ctx._getErrors();
+	assert.equal(errs.length, 1);
+	assert.deepEqual(errs[0].detail, { limit: 3, actual: 4 });
+});