@nyaomaru/divider 1.6.1 → 1.7.0

package/README.md

@@ -152,10 +152,11 @@ const result3 = dividerNumberString(['abc123', '45z'], { flatten: true });
 
 ## 🎯 Options
 
-| Option    | Type      | Default | Description                                                               |
-| --------- | --------- | ------- | ------------------------------------------------------------------------- |
-| `flatten` | `boolean` | `false` | If `true`, the resulting nested arrays are flattened into a single array. |
-| `trim`    | `boolean` | `false` | If `true`, trims whitespace from each divided segment.                    |
+| Option         | Type      | Default | Description                                                               |
+| -------------- | ----------| ------- | ------------------------------------------------------------------------- |
+| `flatten`      | `boolean` | `false` | If `true`, the resulting nested arrays are flattened into a single array. |
+| `trim`         | `boolean` | `false` | If `true`, trims whitespace from each divided segment.                    |
+| `excludeEmpty` | `boolean` | `false` | If `true`, removes empty strings or strings with only whitespace.         |
 
 ### `flatten` (default: `false`)
 
@@ -181,24 +182,29 @@ const result2 = divider(['  a  ', ' b  c '], ' ', {
 // ['a', 'b', 'c']
 ```
 
-## 💡 Features
-
-### 🧩 Flexible Division
-
-- Supports both `index-based` and `string-based` division
-- Supports `multiple separators` (mixing indexes and characters)
-- Works with both `string` and `string[]` input
-- Optional `flatten` and `trim` behaviors to control output format
-- Includes `dividerNumberString()` to separate digits and letters
+### `excludeEmpty` (default: `false`)
 
-### 🎯 Targeted Extraction
+```ts
+// Remove empty strings or strings with only spaces
+const result = divider('a, ,b', ',', { trim: true, excludeEmpty: true });
+// ['a', 'b']
 
-- `dividerFirst()`: Get only the first divided element
-- `dividerLast()`: Get only the last divided element
+const result2 = divider(['  a  ', ' ', '  b'], ' ', {
+  flatten: true,
+  trim: true,
+  excludeEmpty: true,
+});
+// ['a', 'b']
+```
 
-### 🔁 Repeated Division
+## 💡 Features
 
-- `dividerLoop()`: Automatically divide into fixed-size chunks
+- 🧩 Flexible Division: Index-based and string-based separators
+- 🧵 Handles Nested Input: Supports both string and string[]
+- 🎛️ Optional Behaviors: flatten, trim, excludeEmpty
+- 🎯 Targeted Extractors: dividerFirst(), dividerLast()
+- 🔁 Loop Support: dividerLoop() for chunked division
+- 🔢 Digit-Letter Splitter: dividerNumberString()
 
 ## 🛠 Contributing
 

package/dist/index.cjs

@@ -28,11 +28,19 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/core/constants.ts
+var dividerOptionKeys = ["flatten", "trim", "excludeEmpty"];
+
 // src/utils/is.ts
-var isString = (arg) => typeof arg === "string";
-var isNumber = (arg) => typeof arg === "number";
+function isString(arg) {
+  return typeof arg === "string";
+}
+function isNumber(arg) {
+  return typeof arg === "number";
+}
 function isOptions(arg) {
-  return typeof arg === "object" && arg !== null && "flatten" in arg;
+  if (typeof arg !== "object" || arg === null) return false;
+  return dividerOptionKeys.some((key) => key in arg);
 }
 function isEmptyArray(input) {
   return Array.isArray(input) && input.length === 0;
@@ -49,6 +57,9 @@ function isStringArray(input) {
 function isNestedStringArray(input) {
   return Array.isArray(input) && input.length > 0 && Array.isArray(input[0]) && input[0].length > 0 && isStringArray(input[0]);
 }
+function isWhitespaceOnly(s) {
+  return s.trim() === "";
+}
 
 // src/utils/regex.ts
 var regexCache = /* @__PURE__ */ new Map();
@@ -101,11 +112,11 @@ function divideString(input, numSeparators, strSeparators) {
 }
 
 // src/utils/array.ts
-function ensureArray(input) {
-  return Array.isArray(input) ? input : [input];
+function ensureStringArray(input) {
+  return typeof input === "string" ? [input] : input;
 }
 
-// src/utils/options.ts
+// src/utils/option.ts
 function extractOptions(args) {
   const clonedArgs = [...args];
   const lastArg = clonedArgs.at(-1);
@@ -118,6 +129,20 @@ function extractOptions(args) {
     options
   };
 }
+function applyDividerOptions(result, options) {
+  let output = result;
+  if (options.trim) {
+    const trim = (s) => s.trim();
+    output = isNestedStringArray(output) ? output.map((row) => row.map(trim).filter(Boolean)) : output.map(trim).filter(Boolean);
+  }
+  if (options.flatten) {
+    output = output.flat();
+  }
+  if (options.excludeEmpty) {
+    output = isNestedStringArray(output) ? output.filter((arr) => arr.some((s) => !isWhitespaceOnly(s))) : output.filter((s) => !isWhitespaceOnly(s));
+  }
+  return output;
+}
 
 // src/utils/separator.ts
 function classifySeparators(args) {
@@ -131,19 +156,6 @@ function classifySeparators(args) {
   );
 }
 
-// src/utils/option.ts
-function applyDividerOptions(result, options) {
-  let output = result;
-  if (options.trim) {
-    const trim = (s) => s.trim();
-    output = isNestedStringArray(output) ? output.map((row) => row.map(trim).filter(Boolean)) : output.map(trim).filter(Boolean);
-  }
-  if (options.flatten) {
-    output = output.flat();
-  }
-  return output;
-}
-
 // src/core/divider.ts
 function divider(input, ...args) {
   if (!isValidInput(input)) {
@@ -153,7 +165,7 @@ function divider(input, ...args) {
     return [];
   }
   if (isEmptyArray(args)) {
-    return ensureArray(input);
+    return ensureStringArray(input);
   }
   const { cleanedArgs, options } = extractOptions(args);
   const { numSeparators, strSeparators } = classifySeparators(cleanedArgs);

package/dist/index.d.cts

@@ -1,16 +1,19 @@
-type DividerResult<T extends string | string[], F extends boolean = false> = T extends string ? string[] : F extends true ? string[] : string[][];
-type DividerOptions<F extends boolean> = Partial<Record<'flatten' | 'trim', F>>;
+declare const dividerOptionKeys: readonly ["flatten", "trim", "excludeEmpty"];
+
+type DividerOptionKey = (typeof dividerOptionKeys)[number];
+type DividerResult<T extends string | string[]> = T extends string ? string[] : string[][];
+type DividerOptions = Partial<Record<DividerOptionKey, boolean>>;
 type DividerSeparators = (number | string)[];
-type DividerArgs<F extends boolean> = DividerSeparators | [...DividerSeparators, DividerOptions<F>];
+type DividerArgs = DividerSeparators | [...DividerSeparators, DividerOptions];
 
-declare function divider<T extends string | string[], F extends boolean>(input: T, ...args: DividerArgs<F>): DividerResult<T, F>;
+declare function divider<T extends string | string[]>(input: T, ...args: DividerArgs): DividerResult<T>;
 
 declare function dividerFirst(input: string | string[], ...args: DividerSeparators): string;
 
 declare function dividerLast(input: string | string[], ...args: DividerSeparators): string;
 
-declare function dividerLoop<T extends string | string[], F extends boolean>(input: T, size: number, options?: DividerOptions<F>): DividerResult<T, F>;
+declare function dividerLoop<T extends string | string[]>(input: T, size: number, options?: DividerOptions): DividerResult<T>;
 
-declare function dividerNumberString<T extends string | string[], F extends boolean = false>(input: T, options?: DividerOptions<F>): DividerResult<T, F>;
+declare function dividerNumberString<T extends string | string[]>(input: T, options?: DividerOptions): DividerResult<T>;
 
 export { type DividerResult, divider, dividerFirst, dividerLast, dividerLoop, dividerNumberString };

package/dist/index.d.ts

@@ -1,16 +1,19 @@
-type DividerResult<T extends string | string[], F extends boolean = false> = T extends string ? string[] : F extends true ? string[] : string[][];
-type DividerOptions<F extends boolean> = Partial<Record<'flatten' | 'trim', F>>;
+declare const dividerOptionKeys: readonly ["flatten", "trim", "excludeEmpty"];
+
+type DividerOptionKey = (typeof dividerOptionKeys)[number];
+type DividerResult<T extends string | string[]> = T extends string ? string[] : string[][];
+type DividerOptions = Partial<Record<DividerOptionKey, boolean>>;
 type DividerSeparators = (number | string)[];
-type DividerArgs<F extends boolean> = DividerSeparators | [...DividerSeparators, DividerOptions<F>];
+type DividerArgs = DividerSeparators | [...DividerSeparators, DividerOptions];
 
-declare function divider<T extends string | string[], F extends boolean>(input: T, ...args: DividerArgs<F>): DividerResult<T, F>;
+declare function divider<T extends string | string[]>(input: T, ...args: DividerArgs): DividerResult<T>;
 
 declare function dividerFirst(input: string | string[], ...args: DividerSeparators): string;
 
 declare function dividerLast(input: string | string[], ...args: DividerSeparators): string;
 
-declare function dividerLoop<T extends string | string[], F extends boolean>(input: T, size: number, options?: DividerOptions<F>): DividerResult<T, F>;
+declare function dividerLoop<T extends string | string[]>(input: T, size: number, options?: DividerOptions): DividerResult<T>;
 
-declare function dividerNumberString<T extends string | string[], F extends boolean = false>(input: T, options?: DividerOptions<F>): DividerResult<T, F>;
+declare function dividerNumberString<T extends string | string[]>(input: T, options?: DividerOptions): DividerResult<T>;
 
 export { type DividerResult, divider, dividerFirst, dividerLast, dividerLoop, dividerNumberString };

package/dist/index.js

@@ -1,8 +1,16 @@
+// src/core/constants.ts
+var dividerOptionKeys = ["flatten", "trim", "excludeEmpty"];
+
 // src/utils/is.ts
-var isString = (arg) => typeof arg === "string";
-var isNumber = (arg) => typeof arg === "number";
+function isString(arg) {
+  return typeof arg === "string";
+}
+function isNumber(arg) {
+  return typeof arg === "number";
+}
 function isOptions(arg) {
-  return typeof arg === "object" && arg !== null && "flatten" in arg;
+  if (typeof arg !== "object" || arg === null) return false;
+  return dividerOptionKeys.some((key) => key in arg);
 }
 function isEmptyArray(input) {
   return Array.isArray(input) && input.length === 0;
@@ -19,6 +27,9 @@ function isStringArray(input) {
 function isNestedStringArray(input) {
   return Array.isArray(input) && input.length > 0 && Array.isArray(input[0]) && input[0].length > 0 && isStringArray(input[0]);
 }
+function isWhitespaceOnly(s) {
+  return s.trim() === "";
+}
 
 // src/utils/regex.ts
 var regexCache = /* @__PURE__ */ new Map();
@@ -71,11 +82,11 @@ function divideString(input, numSeparators, strSeparators) {
 }
 
 // src/utils/array.ts
-function ensureArray(input) {
-  return Array.isArray(input) ? input : [input];
+function ensureStringArray(input) {
+  return typeof input === "string" ? [input] : input;
 }
 
-// src/utils/options.ts
+// src/utils/option.ts
 function extractOptions(args) {
   const clonedArgs = [...args];
   const lastArg = clonedArgs.at(-1);
@@ -88,6 +99,20 @@ function extractOptions(args) {
     options
   };
 }
+function applyDividerOptions(result, options) {
+  let output = result;
+  if (options.trim) {
+    const trim = (s) => s.trim();
+    output = isNestedStringArray(output) ? output.map((row) => row.map(trim).filter(Boolean)) : output.map(trim).filter(Boolean);
+  }
+  if (options.flatten) {
+    output = output.flat();
+  }
+  if (options.excludeEmpty) {
+    output = isNestedStringArray(output) ? output.filter((arr) => arr.some((s) => !isWhitespaceOnly(s))) : output.filter((s) => !isWhitespaceOnly(s));
+  }
+  return output;
+}
 
 // src/utils/separator.ts
 function classifySeparators(args) {
@@ -101,19 +126,6 @@ function classifySeparators(args) {
   );
 }
 
-// src/utils/option.ts
-function applyDividerOptions(result, options) {
-  let output = result;
-  if (options.trim) {
-    const trim = (s) => s.trim();
-    output = isNestedStringArray(output) ? output.map((row) => row.map(trim).filter(Boolean)) : output.map(trim).filter(Boolean);
-  }
-  if (options.flatten) {
-    output = output.flat();
-  }
-  return output;
-}
-
 // src/core/divider.ts
 function divider(input, ...args) {
   if (!isValidInput(input)) {
@@ -123,7 +135,7 @@ function divider(input, ...args) {
     return [];
   }
   if (isEmptyArray(args)) {
-    return ensureArray(input);
+    return ensureStringArray(input);
   }
   const { cleanedArgs, options } = extractOptions(args);
   const { numSeparators, strSeparators } = classifySeparators(cleanedArgs);

package/package.json

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