@nyaomaru/divider 1.0.6 → 1.0.8

package/README.md

@@ -23,13 +23,27 @@ A simple utility to divide a `string` or `string[]` based on given indexes or de
 
 ## 🚀 Installation
 
+You can install `@nyaomaru/divider` using your favorite package manager:
+
 ```sh
+# Using pnpm (recommended)
 pnpm install @nyaomaru/divider
+
+# Using npm
+npm install @nyaomaru/divider
+
+# Using bun
+bun add @nyaomaru/divider
+
+# Using yarn
+yarn add @nyaomaru/divider
 ```
 
 ## 📖 Usage
 
-### Basic Examples
+👉 [Check out the full documentation here!](https://divider-docs.vercel.app/)
+
+### 📌 Basic Usage
 
 ```ts
 import { divider } from '@nyaomaru/divider';
@@ -58,7 +72,7 @@ const dividedWordsWithFlattenOption = divider(words, 2, { flatten: true });
 // ['he', 'llo', 'wo', 'rld']
 ```
 
-### Advanced Examples
+### 📌 Advanced Usage
 
 ```ts
 // Mixed usage of indexes and characters

package/dist/cjs/index.js

@@ -1,62 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.divider = divider;
+const slice_1 = require("@/utils/slice");
+const regex_1 = require("@/utils/regex");
 function divider(input, ...args) {
-    // extract the options from the input
+    // Extract the options from the input
     const lastArg = args[args.length - 1];
     const options = isOptions(lastArg) ? lastArg : {};
-    // filter out only numbers and strings
-    const separators = args.filter((arg) => typeof arg === 'number' || typeof arg === 'string');
+    // Filter out only numbers and strings
+    const numSeparators = [];
+    const strSeparators = [];
+    for (const arg of args) {
+        if (typeof arg === 'number') {
+            numSeparators.push(arg);
+        }
+        else if (typeof arg === 'string') {
+            strSeparators.push(arg);
+        }
+    }
     if (typeof input === 'string') {
-        return divideString(input, separators);
+        return divideString(input, numSeparators, strSeparators);
     }
-    const result = input.map((item) => divideString(item, separators));
+    const result = input.map((item) => divideString(item, numSeparators, strSeparators));
     return (options.flatten ? result.flat() : result);
 }
-function divideString(input, separators) {
-    if (separators.length === 0) {
+function divideString(input, numSeparators, strSeparators) {
+    if (numSeparators.length === 0 && strSeparators.length === 0) {
         return [input];
     }
-    const { numSeparators, strSeparators } = separators.reduce((acc, separator) => {
-        typeof separator === 'number'
-            ? acc.numSeparators.push(separator)
-            : acc.strSeparators.push(separator);
-        return acc;
-    }, { numSeparators: [], strSeparators: [] });
-    // If there are no number delimiters, split by string delimiters only
-    if (numSeparators.length === 0 && strSeparators.length > 0) {
-        return input
-            .split(new RegExp(`[${strSeparators.map(escapeRegExp).join('')}]`, 'g'))
-            .filter(Boolean);
-    }
+    // Precompile regex for string separators
+    const regex = (0, regex_1.getRegex)(strSeparators);
     // Divide by number delimiters
-    let parts = sliceByIndexes(input, numSeparators);
+    let parts = (0, slice_1.sliceByIndexes)(input, numSeparators);
     // Divide by string delimiters
-    if (strSeparators.length) {
-        const regex = new RegExp(`[${strSeparators.map(escapeRegExp).join('')}]`, 'g');
+    if (regex) {
         parts = parts.flatMap((part) => part.split(regex)).filter(Boolean);
     }
     return parts;
 }
-function sliceByIndexes(input, indexes) {
-    if (!indexes.length)
-        return [input];
-    const sortedIndexes = indexes.slice().sort((a, b) => a - b);
-    const parts = new Array(sortedIndexes.length + 1).fill(null);
-    let start = 0;
-    for (let i = 0; i < sortedIndexes.length; i++) {
-        const index = sortedIndexes[i];
-        if (index > start && index < input.length) {
-            parts[i] = input.slice(start, index);
-            start = index;
-        }
-    }
-    parts[sortedIndexes.length] = input.slice(start);
-    return parts.filter(Boolean);
-}
 function isOptions(arg) {
     return typeof arg === 'object' && arg !== null && 'flatten' in arg;
 }
-function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/dist/cjs/utils/regex.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegex = getRegex;
+const regexCache = new Map();
+function getRegex(separators) {
+    if (separators.length === 0)
+        return null;
+    const key = separators.join('');
+    if (!regexCache.has(key)) {
+        regexCache.set(key, new RegExp(`[${separators.map(escapeRegExp).join('')}]`, 'g'));
+    }
+    return regexCache.get(key);
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/cjs/utils/slice.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceByIndexes = sliceByIndexes;
+function sliceByIndexes(input, indexes) {
+    if (!indexes.length)
+        return [input];
+    const sortedIndexes = indexes.slice().sort((a, b) => a - b);
+    const parts = [];
+    let start = 0;
+    for (const index of sortedIndexes) {
+        if (index > start && index < input.length) {
+            parts.push(input.slice(start, index));
+            start = index;
+        }
+    }
+    parts.push(input.slice(start));
+    return parts.filter(Boolean);
+}

package/dist/cjs/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/index.js

@@ -1,59 +1,40 @@
+import { sliceByIndexes } from '@/utils/slice';
+import { getRegex } from '@/utils/regex';
 export function divider(input, ...args) {
-    // extract the options from the input
+    // Extract the options from the input
     const lastArg = args[args.length - 1];
     const options = isOptions(lastArg) ? lastArg : {};
-    // filter out only numbers and strings
-    const separators = args.filter((arg) => typeof arg === 'number' || typeof arg === 'string');
+    // Filter out only numbers and strings
+    const numSeparators = [];
+    const strSeparators = [];
+    for (const arg of args) {
+        if (typeof arg === 'number') {
+            numSeparators.push(arg);
+        }
+        else if (typeof arg === 'string') {
+            strSeparators.push(arg);
+        }
+    }
     if (typeof input === 'string') {
-        return divideString(input, separators);
+        return divideString(input, numSeparators, strSeparators);
     }
-    const result = input.map((item) => divideString(item, separators));
+    const result = input.map((item) => divideString(item, numSeparators, strSeparators));
     return (options.flatten ? result.flat() : result);
 }
-function divideString(input, separators) {
-    if (separators.length === 0) {
+function divideString(input, numSeparators, strSeparators) {
+    if (numSeparators.length === 0 && strSeparators.length === 0) {
         return [input];
     }
-    const { numSeparators, strSeparators } = separators.reduce((acc, separator) => {
-        typeof separator === 'number'
-            ? acc.numSeparators.push(separator)
-            : acc.strSeparators.push(separator);
-        return acc;
-    }, { numSeparators: [], strSeparators: [] });
-    // If there are no number delimiters, split by string delimiters only
-    if (numSeparators.length === 0 && strSeparators.length > 0) {
-        return input
-            .split(new RegExp(`[${strSeparators.map(escapeRegExp).join('')}]`, 'g'))
-            .filter(Boolean);
-    }
+    // Precompile regex for string separators
+    const regex = getRegex(strSeparators);
     // Divide by number delimiters
     let parts = sliceByIndexes(input, numSeparators);
     // Divide by string delimiters
-    if (strSeparators.length) {
-        const regex = new RegExp(`[${strSeparators.map(escapeRegExp).join('')}]`, 'g');
+    if (regex) {
         parts = parts.flatMap((part) => part.split(regex)).filter(Boolean);
     }
     return parts;
 }
-function sliceByIndexes(input, indexes) {
-    if (!indexes.length)
-        return [input];
-    const sortedIndexes = indexes.slice().sort((a, b) => a - b);
-    const parts = new Array(sortedIndexes.length + 1).fill(null);
-    let start = 0;
-    for (let i = 0; i < sortedIndexes.length; i++) {
-        const index = sortedIndexes[i];
-        if (index > start && index < input.length) {
-            parts[i] = input.slice(start, index);
-            start = index;
-        }
-    }
-    parts[sortedIndexes.length] = input.slice(start);
-    return parts.filter(Boolean);
-}
 function isOptions(arg) {
     return typeof arg === 'object' && arg !== null && 'flatten' in arg;
 }
-function escapeRegExp(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

package/dist/esm/utils/regex.js

@@ -0,0 +1,13 @@
+const regexCache = new Map();
+export function getRegex(separators) {
+    if (separators.length === 0)
+        return null;
+    const key = separators.join('');
+    if (!regexCache.has(key)) {
+        regexCache.set(key, new RegExp(`[${separators.map(escapeRegExp).join('')}]`, 'g'));
+    }
+    return regexCache.get(key);
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/esm/utils/slice.js

@@ -0,0 +1,15 @@
+export function sliceByIndexes(input, indexes) {
+    if (!indexes.length)
+        return [input];
+    const sortedIndexes = indexes.slice().sort((a, b) => a - b);
+    const parts = [];
+    let start = 0;
+    for (const index of sortedIndexes) {
+        if (index > start && index < input.length) {
+            parts.push(input.slice(start, index));
+            start = index;
+        }
+    }
+    parts.push(input.slice(start));
+    return parts.filter(Boolean);
+}

package/dist/esm/utils/types.js

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

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-type DividerResult<T extends string | string[], F extends boolean | undefined> = T extends string ? string[] : F extends true ? string[] : string[][];
+import type { DividerResult } from '@/utils/types';
 export declare function divider<T extends string | string[]>(input: string | string[], ...args: (number | string | {
     flatten?: boolean;
 })[]): DividerResult<T, boolean>;
-export {};

package/dist/utils/regex.d.ts

@@ -0,0 +1 @@
+export declare function getRegex(separators: string[]): RegExp | null;

package/dist/utils/slice.d.ts

@@ -0,0 +1 @@
+export declare function sliceByIndexes(input: string, indexes: number[]): string[];

package/dist/utils/types.d.ts

@@ -0,0 +1 @@
+export type DividerResult<T extends string | string[], F extends boolean = false> = T extends string ? string[] : F extends true ? string[] : string[][];

package/package.json

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