@nyaomaru/divider 1.4.0 → 1.5.0

package/README.md

@@ -132,6 +132,24 @@ const result2 = dividerLoop(['hello', 'world'], 2, { flatten: true });
 // ['he', 'll', 'ow', 'or', 'ld']
 ```
 
+### 📌 `dividerNumberString()` Usage
+
+```ts
+import { dividerNumberString } from '@nyaomaru/divider';
+
+// Split numbers and letters from a string
+const result = dividerNumberString('abc123def456');
+// ['abc', '123', 'def', '456']
+
+// Split each string in a string[]
+const result2 = dividerNumberString(['abc123', '45z']);
+// [['abc', '123'], ['45', 'z']]
+
+// Flatten option
+const result3 = dividerNumberString(['abc123', '45z'], { flatten: true });
+// ['abc', '123', '45', 'z']
+```
+
 ## 🎯 Options
 
 | Option    | Type      | Default | Description                                                               |
@@ -157,6 +175,7 @@ const result2 = divider(words, 2, { flatten: true });
 - Supports `multiple separators` (mixing indexes and characters)
 - Works with both `string` and `string[]` input
 - Optional `flatten` behavior to control nested results
+- Includes `dividerNumberString()` to separate digits and letters
 
 ### 🎯 Targeted Extraction
 

package/dist/cjs/core/divider-loop.js

@@ -6,18 +6,18 @@ const chunk_1 = require("@/utils/chunk");
 const divider_1 = require("@/core/divider");
 function dividerLoop(input, size, options) {
     var _a;
-    if (!(0, is_1.isNumber)(size) || size <= 0) {
+    if (!(0, is_1.isPositiveInteger)(size)) {
         console.warn('dividerLoop: chunk size must be a positive number');
         return [];
     }
-    const flatten = (_a = options === null || options === void 0 ? void 0 : options.flatten) !== null && _a !== void 0 ? _a : false;
     if ((0, is_1.isString)(input)) {
         const indexes = (0, chunk_1.generateIndexes)(input, size);
-        return (0, divider_1.divider)(input, ...indexes, { flatten });
+        return (0, divider_1.divider)(input, ...indexes);
     }
     const result = input.map((item) => {
         const indexes = (0, chunk_1.generateIndexes)(item, size);
         return (0, divider_1.divider)(item, ...indexes);
     });
+    const flatten = (_a = options === null || options === void 0 ? void 0 : options.flatten) !== null && _a !== void 0 ? _a : false;
     return (flatten ? result.flat() : result);
 }

package/dist/cjs/core/divider-number-string.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dividerNumberString = dividerNumberString;
+const is_1 = require("@/utils/is");
+function dividerNumberString(input, options) {
+    const regex = /\d+|\D+/g;
+    const divide = (str) => {
+        return (str.match(regex) || []).filter(Boolean);
+    };
+    if ((0, is_1.isString)(input)) {
+        return divide(input);
+    }
+    const result = input.map(divide);
+    return ((options === null || options === void 0 ? void 0 : options.flatten) ? result.flat() : result);
+}

package/dist/cjs/utils/is.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNumber = exports.isString = void 0;
 exports.isOptions = isOptions;
 exports.isEmptyArray = isEmptyArray;
+exports.isPositiveInteger = isPositiveInteger;
 const isString = (arg) => typeof arg === 'string';
 exports.isString = isString;
 const isNumber = (arg) => typeof arg === 'number';
@@ -13,3 +14,6 @@ function isOptions(arg) {
 function isEmptyArray(input) {
     return Array.isArray(input) && input.length === 0;
 }
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}

package/dist/esm/core/divider-loop.js

@@ -1,20 +1,20 @@
-import { isString, isNumber } from '@/utils/is';
+import { isString, isPositiveInteger } from '@/utils/is';
 import { generateIndexes } from '@/utils/chunk';
 import { divider } from '@/core/divider';
 export function dividerLoop(input, size, options) {
     var _a;
-    if (!isNumber(size) || size <= 0) {
+    if (!isPositiveInteger(size)) {
         console.warn('dividerLoop: chunk size must be a positive number');
         return [];
     }
-    const flatten = (_a = options === null || options === void 0 ? void 0 : options.flatten) !== null && _a !== void 0 ? _a : false;
     if (isString(input)) {
         const indexes = generateIndexes(input, size);
-        return divider(input, ...indexes, { flatten });
+        return divider(input, ...indexes);
     }
     const result = input.map((item) => {
         const indexes = generateIndexes(item, size);
         return divider(item, ...indexes);
     });
+    const flatten = (_a = options === null || options === void 0 ? void 0 : options.flatten) !== null && _a !== void 0 ? _a : false;
     return (flatten ? result.flat() : result);
 }

package/dist/esm/core/divider-number-string.js

@@ -0,0 +1,12 @@
+import { isString } from '@/utils/is';
+export function dividerNumberString(input, options) {
+    const regex = /\d+|\D+/g;
+    const divide = (str) => {
+        return (str.match(regex) || []).filter(Boolean);
+    };
+    if (isString(input)) {
+        return divide(input);
+    }
+    const result = input.map(divide);
+    return ((options === null || options === void 0 ? void 0 : options.flatten) ? result.flat() : result);
+}

package/dist/esm/utils/is.js

@@ -6,3 +6,6 @@ export function isOptions(arg) {
 export function isEmptyArray(input) {
     return Array.isArray(input) && input.length === 0;
 }
+export function isPositiveInteger(value) {
+    return Number.isInteger(value) && value > 0;
+}

package/dist/types/core/divider-number-string.d.ts

@@ -0,0 +1,2 @@
+import type { DividerOptions, DividerResult } from '@/core/types';
+export declare function dividerNumberString<T extends string | string[], F extends boolean = false>(input: T, options?: DividerOptions<F>): DividerResult<T, F>;

package/dist/types/utils/is.d.ts

@@ -4,3 +4,4 @@ export declare function isOptions(arg: unknown): arg is {
     flatten?: boolean;
 };
 export declare function isEmptyArray<T>(input: T[]): boolean;
+export declare function isPositiveInteger(value: unknown): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nyaomaru/divider",
   "type": "module",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "To divide string or string[] with a given separator",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",