muggle-string 0.2.0 → 0.2.2

package/out/binarySearch.d.ts

@@ -0,0 +1 @@
+export declare function binarySearch(offsets: number[], start: number): number;

package/out/binarySearch.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binarySearch = void 0;
+function binarySearch(offsets, start) {
+    let low = 0;
+    let high = offsets.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const midValue = offsets[mid];
+        if (midValue < start) {
+            low = mid + 1;
+        }
+        else if (midValue > start) {
+            high = mid - 1;
+        }
+        else {
+            low = mid;
+            high = mid;
+            break;
+        }
+    }
+    return Math.max(Math.min(low, high, offsets.length - 1), 0);
+}
+exports.binarySearch = binarySearch;
+//# sourceMappingURL=binarySearch.js.map

package/out/index.d.ts

@@ -1,25 +1,20 @@
 declare const NO_DATA_SYMBOL: unique symbol;
-export type Segment<T = typeof NO_DATA_SYMBOL> = T extends typeof NO_DATA_SYMBOL ? SegmentWithoutData : SegmentWithData<T>;
-export type SegmentWithoutData = WithString<_SegmentWithoutData>;
-export type SegmentWithData<T = any> = WithString<_SegmentWithData<T>>;
-type WithString<T> = T | string;
-type _SegmentWithoutData = [
+export type Segment<T = typeof NO_DATA_SYMBOL> = WithString<T extends typeof NO_DATA_SYMBOL ? [
     string,
-    // text
     string | undefined,
-    // source
     number | [number, number]
-];
-type _SegmentWithData<T = any> = [
+] : [
     string,
-    // text
     string | undefined,
-    // source
     number | [number, number],
     T
-];
+]>;
+type WithString<T> = T | string;
 export declare function getLength(segments: Segment<any>[]): number;
 export declare function toString<T extends Segment<any>>(segments: T[]): string;
-export declare function replace<T extends Segment<any>>(segments: T[], pattern: string | RegExp, replacer: string | ((match: string) => T)): void;
-export declare function update<T extends Segment<any>>(segments: T[], startOffset: number, endOffset: number, newSegment: T): void;
+export declare function create(source: string): Segment[];
+export declare function replace<T extends Segment<any>>(segments: T[], pattern: string | RegExp, ...replacers: (T | ((match: string) => T))[]): void;
+export declare function replaceAll<T extends Segment<any>>(segments: T[], pattern: RegExp, ...replacers: (T | ((match: string) => T))[]): void;
+export declare function replaceSourceRange<T extends Segment<any>>(segments: T[], source: string | undefined, startOffset: number, endOffset: number, ...newSegments: T[]): boolean;
+export declare function replaceRange<T extends Segment<any>>(segments: T[], startOffset: number, endOffset: number, ...newSegments: T[]): void;
 export {};

package/out/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.update = exports.replace = exports.toString = exports.getLength = void 0;
+exports.replaceRange = exports.replaceSourceRange = exports.replaceAll = exports.replace = exports.create = exports.toString = exports.getLength = void 0;
+const binarySearch_1 = require("./binarySearch");
 const NO_DATA_SYMBOL = Symbol();
 function getLength(segments) {
     let length = 0;
@@ -14,36 +15,88 @@ function toString(segments) {
     return segments.map(s => typeof s === 'string' ? s : s[0]).join('');
 }
 exports.toString = toString;
-function replace(segments, pattern, replacer) {
+function create(source) {
+    return [[source, undefined, 0]];
+}
+exports.create = create;
+function replace(segments, pattern, ...replacers) {
     const str = toString(segments);
     const match = str.match(pattern);
     if (match && match.index !== undefined) {
         const startOffset = match.index;
         const endOffset = startOffset + match[0].length;
-        update(segments, startOffset, endOffset, typeof replacer === 'string' ? replacer : replacer(match[0]));
+        replaceRange(segments, startOffset, endOffset, ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
     }
 }
 exports.replace = replace;
-function update(segments, startOffset, endOffset, newSegment) {
+function replaceAll(segments, pattern, ...replacers) {
+    const str = toString(segments);
+    const allMatch = str.matchAll(pattern);
+    let length = str.length;
+    let lengthDiff = 0;
+    for (const match of allMatch) {
+        if (match.index !== undefined) {
+            const startOffset = match.index + lengthDiff;
+            const endOffset = startOffset + match[0].length;
+            replaceRange(segments, startOffset, endOffset, ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
+            const newLength = getLength(segments);
+            lengthDiff += newLength - length;
+            length = newLength;
+        }
+    }
+}
+exports.replaceAll = replaceAll;
+function replaceSourceRange(segments, source, startOffset, endOffset, ...newSegments) {
+    for (const segment of segments) {
+        if (typeof segment === 'string') {
+            continue;
+        }
+        if (segment[1] === source) {
+            const segmentStart = typeof segment[2] === 'number' ? segment[2] : segment[2][0];
+            const segmentEnd = typeof segment[2] === 'number' ? segment[2] + segment[0].length : segment[2][1];
+            if (segmentStart <= startOffset && segmentEnd >= endOffset) {
+                const inserts = [];
+                if (startOffset > segmentStart) {
+                    inserts.push(trimSegmentEnd(segment, startOffset - segmentStart));
+                }
+                for (const newSegment of newSegments) {
+                    inserts.push(newSegment);
+                }
+                if (endOffset < segmentEnd) {
+                    inserts.push(trimSegmentStart(segment, endOffset - segmentEnd));
+                }
+                combineStrings(inserts);
+                segments.splice(segments.indexOf(segment), 1, ...inserts);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+exports.replaceSourceRange = replaceSourceRange;
+function replaceRange(segments, startOffset, endOffset, ...newSegments) {
     const offsets = toOffsets(segments);
-    const startIndex = binarySearchStartIndex(offsets, startOffset);
-    const endIndex = binarySearchEndIndex(offsets, endOffset);
+    const startIndex = (0, binarySearch_1.binarySearch)(offsets, startOffset);
+    const endIndex = (0, binarySearch_1.binarySearch)(offsets, endOffset);
     const startSegment = segments[startIndex];
     const endSegment = segments[endIndex];
     const startSegmentStart = offsets[startIndex];
+    const endSegmentStart = offsets[endIndex];
     const endSegmentEnd = offsets[endIndex] + (typeof endSegment === 'string' ? endSegment.length : endSegment[0].length);
     const inserts = [];
     if (startOffset > startSegmentStart) {
         inserts.push(trimSegmentEnd(startSegment, startOffset - startSegmentStart));
     }
-    inserts.push(newSegment);
+    for (const newSegment of newSegments) {
+        inserts.push(newSegment);
+    }
     if (endOffset < endSegmentEnd) {
-        inserts.push(trimSegmentStart(endSegment, endOffset - startSegmentStart));
+        inserts.push(trimSegmentStart(endSegment, endOffset - endSegmentStart));
     }
     combineStrings(inserts);
     segments.splice(startIndex, endIndex - startIndex + 1, ...inserts);
 }
-exports.update = update;
+exports.replaceRange = replaceRange;
 function combineStrings(segments) {
     for (let i = segments.length - 1; i >= 1; i--) {
         if (typeof segments[i] === 'string' && typeof segments[i - 1] === 'string') {
@@ -74,6 +127,9 @@ function trimSegmentStart(segment, trimStart) {
     const originalString = segment[0];
     const originalRange = segment[2];
     const newString = originalString.slice(trimStart);
+    if (trimStart < 0) {
+        trimStart += originalString.length;
+    }
     const newRange = typeof originalRange === 'number' ? originalRange + trimStart : [originalRange[0] + trimStart, originalRange[1]];
     return [
         newString,
@@ -91,31 +147,4 @@ function toOffsets(segments) {
     }
     return offsets;
 }
-function binarySearchStartIndex(offsets, searchOffset) {
-    let start = 0;
-    let end = offsets.length - 1;
-    while (start < end) {
-        const mid = Math.floor((start + end) / 2);
-        if (offsets[mid] < searchOffset) {
-            start = mid + 1;
-        }
-        else {
-            end = mid;
-        }
-    }
-    return start;
-}
-function binarySearchEndIndex(offsets, searchOffset) {
-    let start = 0;
-    let end = offsets.length - 1;
-    while (start < end) {
-        const mid = Math.floor((start + end) / 2);
-        if (offsets[mid] <= searchOffset) {
-            start = mid + 1;
-        }
-        else {
-            end = mid;
-        }
-    }
-    return start;
-}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "muggle-string",
-	"version": "0.2.0",
+	"version": "0.2.2",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [