@nyaomaru/divider 1.8.2 → 1.8.4

package/dist/index.cjs

@@ -28,6 +28,13 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/constants/index.ts
+var DividerExcludeModes = {
+  NONE: "none",
+  EMPTY: "empty",
+  WHITESPACE: "whitespace"
+};
+
 // src/utils/is.ts
 function isString(arg) {
   return typeof arg === "string";
@@ -35,9 +42,10 @@ function isString(arg) {
 function isNumber(arg) {
   return typeof arg === "number";
 }
-function isOptions(arg) {
-  if (typeof arg !== "object" || arg === null) return false;
-  return "flatten" in arg || "trim" in arg || "exclude" in arg;
+function isOptions(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const options = value;
+  return "flatten" in options || "trim" in options || "exclude" in options;
 }
 function isEmptyArray(input) {
   return Array.isArray(input) && input.length === 0;
@@ -61,7 +69,7 @@ function isEmptyString(s) {
   return s === "";
 }
 function isNoneMode(mode) {
-  return mode === "none";
+  return mode === DividerExcludeModes.NONE;
 }
 
 // src/utils/regex.ts
@@ -221,23 +229,21 @@ function dividerLoop(input, size, options) {
     console.warn("dividerLoop: chunk size must be a positive number");
     return [];
   }
-  const { startOffset = 0, maxChunks } = options ?? {};
+  const finalOptions = options ?? {};
+  const { startOffset = 0, maxChunks = 0 } = finalOptions;
   const applyChunking = (str) => {
-    let chunks = divider(str, ...generateIndexes(str, size, startOffset));
-    const shouldTruncateChunks = isNumber(maxChunks) && maxChunks > 0 && chunks.length > maxChunks;
-    if (shouldTruncateChunks) {
-      const head = chunks.slice(0, maxChunks - 1);
-      const tail = chunks.slice(maxChunks - 1).join("");
-      chunks = [...head, tail];
-    }
-    return chunks;
+    const chunks = divider(str, ...generateIndexes(str, size, startOffset));
+    return needsTruncation(chunks) ? truncateChunks(chunks) : chunks;
   };
-  if (isString(input)) {
-    const result2 = applyChunking(input);
-    return applyDividerOptions(result2, options ?? {});
-  }
-  const result = input.map(applyChunking);
-  return applyDividerOptions(result, options ?? {});
+  const needsTruncation = (chunks) => isNumber(maxChunks) && 0 < maxChunks && maxChunks < chunks.length;
+  const truncateChunks = (chunks) => {
+    const HEAD_COUNT = maxChunks - 1;
+    const head = chunks.slice(0, HEAD_COUNT);
+    const tail = chunks.slice(HEAD_COUNT).join("");
+    return [...head, tail];
+  };
+  const result = isString(input) ? applyChunking(input) : input.map(applyChunking);
+  return applyDividerOptions(result, finalOptions);
 }
 
 // src/utils/divide.ts

package/dist/index.d.cts

@@ -1,18 +1,50 @@
-type DividerExcludeMode = 'none' | 'empty' | 'whitespace';
-type DividerResult<T extends string | string[]> = T extends string ? string[] : string[][];
-type DividerOptions = {
+declare const DividerExcludeModes: {
+    readonly NONE: "none";
+    readonly EMPTY: "empty";
+    readonly WHITESPACE: "whitespace";
+};
+
+type DividerExcludeMode = (typeof DividerExcludeModes)[keyof typeof DividerExcludeModes];
+type StringInput = string;
+type StringArrayInput = string[];
+type DividerInput = StringInput | StringArrayInput;
+type DividerStringResult = string[];
+type DividerArrayResult = string[][];
+type DividerResult<T extends DividerInput> = T extends StringInput ? DividerStringResult : DividerArrayResult;
+interface DividerOptions {
+    /** If true, flattens nested arrays into a single array */
     flatten?: boolean;
+    /** If true, trims whitespace from each divided segment */
     trim?: boolean;
+    /** Controls how empty or whitespace segments are handled */
     exclude?: DividerExcludeMode;
-};
-type DividerLoopOptions = DividerOptions & {
+}
+interface DividerLoopOptions extends DividerOptions {
+    /** Starting position for the division (0-based) */
     startOffset?: number;
+    /** Maximum number of chunks to produce */
     maxChunks?: number;
-};
-type DividerSeparators = (number | string)[];
+}
+type NumericSeparator = number;
+type StringSeparator = string;
+type DividerSeparator = NumericSeparator | StringSeparator;
+type DividerSeparators = DividerSeparator[];
 type DividerArgs = DividerSeparators | [...DividerSeparators, DividerOptions];
 
-declare function divider<T extends string | string[]>(input: T, ...args: DividerArgs): DividerResult<T>;
+/**
+ * Main divider function that splits input based on numeric positions or string delimiters.
+ *
+ * This function can:
+ * - Split a string or array of strings
+ * - Use numeric positions and/or string delimiters
+ * - Apply various options like flattening and trimming
+ *
+ * @param input - String or array of strings to divide
+ * @param args - Array of separators (numbers/strings) and optional options object
+ * @returns Divided string segments based on input type and options
+ * @throws {DividerValidationError} If input or separators are invalid
+ */
+declare function divider<T extends DividerInput>(input: T, ...args: DividerArgs): DividerResult<T>;
 
 declare function dividerFirst(input: string | string[], ...args: DividerSeparators): string;
 
@@ -22,4 +54,4 @@ declare function dividerLoop<T extends string | string[]>(input: T, size: number
 
 declare function dividerNumberString<T extends string | string[]>(input: T, options?: DividerOptions): DividerResult<T>;
 
-export { type DividerArgs, type DividerExcludeMode, type DividerLoopOptions, type DividerOptions, type DividerResult, type DividerSeparators, divider, dividerFirst, dividerLast, dividerLoop, dividerNumberString };
+export { type DividerArgs, type DividerArrayResult, type DividerExcludeMode, type DividerInput, type DividerLoopOptions, type DividerOptions, type DividerResult, type DividerSeparator, type DividerSeparators, type DividerStringResult, type NumericSeparator, type StringArrayInput, type StringInput, type StringSeparator, divider, dividerFirst, dividerLast, dividerLoop, dividerNumberString };

package/dist/index.d.ts

@@ -1,18 +1,50 @@
-type DividerExcludeMode = 'none' | 'empty' | 'whitespace';
-type DividerResult<T extends string | string[]> = T extends string ? string[] : string[][];
-type DividerOptions = {
+declare const DividerExcludeModes: {
+    readonly NONE: "none";
+    readonly EMPTY: "empty";
+    readonly WHITESPACE: "whitespace";
+};
+
+type DividerExcludeMode = (typeof DividerExcludeModes)[keyof typeof DividerExcludeModes];
+type StringInput = string;
+type StringArrayInput = string[];
+type DividerInput = StringInput | StringArrayInput;
+type DividerStringResult = string[];
+type DividerArrayResult = string[][];
+type DividerResult<T extends DividerInput> = T extends StringInput ? DividerStringResult : DividerArrayResult;
+interface DividerOptions {
+    /** If true, flattens nested arrays into a single array */
     flatten?: boolean;
+    /** If true, trims whitespace from each divided segment */
     trim?: boolean;
+    /** Controls how empty or whitespace segments are handled */
     exclude?: DividerExcludeMode;
-};
-type DividerLoopOptions = DividerOptions & {
+}
+interface DividerLoopOptions extends DividerOptions {
+    /** Starting position for the division (0-based) */
     startOffset?: number;
+    /** Maximum number of chunks to produce */
     maxChunks?: number;
-};
-type DividerSeparators = (number | string)[];
+}
+type NumericSeparator = number;
+type StringSeparator = string;
+type DividerSeparator = NumericSeparator | StringSeparator;
+type DividerSeparators = DividerSeparator[];
 type DividerArgs = DividerSeparators | [...DividerSeparators, DividerOptions];
 
-declare function divider<T extends string | string[]>(input: T, ...args: DividerArgs): DividerResult<T>;
+/**
+ * Main divider function that splits input based on numeric positions or string delimiters.
+ *
+ * This function can:
+ * - Split a string or array of strings
+ * - Use numeric positions and/or string delimiters
+ * - Apply various options like flattening and trimming
+ *
+ * @param input - String or array of strings to divide
+ * @param args - Array of separators (numbers/strings) and optional options object
+ * @returns Divided string segments based on input type and options
+ * @throws {DividerValidationError} If input or separators are invalid
+ */
+declare function divider<T extends DividerInput>(input: T, ...args: DividerArgs): DividerResult<T>;
 
 declare function dividerFirst(input: string | string[], ...args: DividerSeparators): string;
 
@@ -22,4 +54,4 @@ declare function dividerLoop<T extends string | string[]>(input: T, size: number
 
 declare function dividerNumberString<T extends string | string[]>(input: T, options?: DividerOptions): DividerResult<T>;
 
-export { type DividerArgs, type DividerExcludeMode, type DividerLoopOptions, type DividerOptions, type DividerResult, type DividerSeparators, divider, dividerFirst, dividerLast, dividerLoop, dividerNumberString };
+export { type DividerArgs, type DividerArrayResult, type DividerExcludeMode, type DividerInput, type DividerLoopOptions, type DividerOptions, type DividerResult, type DividerSeparator, type DividerSeparators, type DividerStringResult, type NumericSeparator, type StringArrayInput, type StringInput, type StringSeparator, divider, dividerFirst, dividerLast, dividerLoop, dividerNumberString };

package/dist/index.js

@@ -1,3 +1,10 @@
+// src/constants/index.ts
+var DividerExcludeModes = {
+  NONE: "none",
+  EMPTY: "empty",
+  WHITESPACE: "whitespace"
+};
+
 // src/utils/is.ts
 function isString(arg) {
   return typeof arg === "string";
@@ -5,9 +12,10 @@ function isString(arg) {
 function isNumber(arg) {
   return typeof arg === "number";
 }
-function isOptions(arg) {
-  if (typeof arg !== "object" || arg === null) return false;
-  return "flatten" in arg || "trim" in arg || "exclude" in arg;
+function isOptions(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const options = value;
+  return "flatten" in options || "trim" in options || "exclude" in options;
 }
 function isEmptyArray(input) {
   return Array.isArray(input) && input.length === 0;
@@ -31,7 +39,7 @@ function isEmptyString(s) {
   return s === "";
 }
 function isNoneMode(mode) {
-  return mode === "none";
+  return mode === DividerExcludeModes.NONE;
 }
 
 // src/utils/regex.ts
@@ -191,23 +199,21 @@ function dividerLoop(input, size, options) {
     console.warn("dividerLoop: chunk size must be a positive number");
     return [];
   }
-  const { startOffset = 0, maxChunks } = options ?? {};
+  const finalOptions = options ?? {};
+  const { startOffset = 0, maxChunks = 0 } = finalOptions;
   const applyChunking = (str) => {
-    let chunks = divider(str, ...generateIndexes(str, size, startOffset));
-    const shouldTruncateChunks = isNumber(maxChunks) && maxChunks > 0 && chunks.length > maxChunks;
-    if (shouldTruncateChunks) {
-      const head = chunks.slice(0, maxChunks - 1);
-      const tail = chunks.slice(maxChunks - 1).join("");
-      chunks = [...head, tail];
-    }
-    return chunks;
+    const chunks = divider(str, ...generateIndexes(str, size, startOffset));
+    return needsTruncation(chunks) ? truncateChunks(chunks) : chunks;
   };
-  if (isString(input)) {
-    const result2 = applyChunking(input);
-    return applyDividerOptions(result2, options ?? {});
-  }
-  const result = input.map(applyChunking);
-  return applyDividerOptions(result, options ?? {});
+  const needsTruncation = (chunks) => isNumber(maxChunks) && 0 < maxChunks && maxChunks < chunks.length;
+  const truncateChunks = (chunks) => {
+    const HEAD_COUNT = maxChunks - 1;
+    const head = chunks.slice(0, HEAD_COUNT);
+    const tail = chunks.slice(HEAD_COUNT).join("");
+    return [...head, tail];
+  };
+  const result = isString(input) ? applyChunking(input) : input.map(applyChunking);
+  return applyDividerOptions(result, finalOptions);
 }
 
 // src/utils/divide.ts

package/package.json

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