muggle-string 0.2.1 → 0.3.0

package/out/index.d.ts

@@ -1,28 +1,9 @@
-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 = [
-    string,
-    // text
-    string | undefined,
-    // source
-    number | [number, number]
-];
-type _SegmentWithData<T = any> = [
-    string,
-    // text
-    string | undefined,
-    // source
-    number | [number, number],
-    T
-];
+import { Segment } from "./types";
+export * from './types';
+export * from './track';
 export declare function getLength(segments: Segment<any>[]): number;
 export declare function toString<T extends Segment<any>>(segments: T[]): string;
-export declare function create(source: string): Segment[];
-export declare function replace<T extends Segment<any>>(segments: T[], pattern: string | RegExp, ...replacers: (string | ((match: string) => T))[]): void;
-export declare function replaceAll<T extends Segment<any>>(segments: T[], pattern: RegExp, ...replacers: (string | ((match: string) => T))[]): void;
-export declare function replaceSourceRange<T extends Segment<any>>(segments: T[], source: string | undefined, startOffset: number, endOffset: number, ...newSegments: T[]): void;
+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,8 +1,24 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceRange = exports.replaceSourceRange = exports.replaceAll = exports.replace = exports.create = exports.toString = exports.getLength = void 0;
+exports.replaceRange = exports.replaceSourceRange = exports.replaceAll = exports.replace = exports.toString = exports.getLength = void 0;
 const binarySearch_1 = require("./binarySearch");
-const NO_DATA_SYMBOL = Symbol();
+const track_1 = require("./track");
+__exportStar(require("./types"), exports);
+__exportStar(require("./track"), exports);
 function getLength(segments) {
     let length = 0;
     for (const segment of segments) {
@@ -15,17 +31,15 @@ function toString(segments) {
     return segments.map(s => typeof s === 'string' ? s : s[0]).join('');
 }
 exports.toString = toString;
-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;
-        replaceRange(segments, startOffset, endOffset, ...replacers.map(replacer => typeof replacer === 'string' ? replacer : replacer(match[0])));
+        (0, track_1.offsetStack)();
+        replaceRange(segments, startOffset, endOffset, ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
+        (0, track_1.resetOffsetStack)();
     }
 }
 exports.replace = replace;
@@ -38,7 +52,9 @@ function replaceAll(segments, pattern, ...replacers) {
         if (match.index !== undefined) {
             const startOffset = match.index + lengthDiff;
             const endOffset = startOffset + match[0].length;
-            replaceRange(segments, startOffset, endOffset, ...replacers.map(replacer => typeof replacer === 'string' ? replacer : replacer(match[0])));
+            (0, track_1.offsetStack)();
+            replaceRange(segments, startOffset, endOffset, ...replacers.map(replacer => typeof replacer === 'function' ? replacer(match[0]) : replacer));
+            (0, track_1.resetOffsetStack)();
             const newLength = getLength(segments);
             lengthDiff += newLength - length;
             length = newLength;
@@ -66,12 +82,14 @@ function replaceSourceRange(segments, source, startOffset, endOffset, ...newSegm
                     inserts.push(trimSegmentStart(segment, endOffset - segmentEnd));
                 }
                 combineStrings(inserts);
+                (0, track_1.offsetStack)();
                 segments.splice(segments.indexOf(segment), 1, ...inserts);
-                return;
+                (0, track_1.resetOffsetStack)();
+                return true;
             }
         }
     }
-    throw new Error(`Source range not found: ${source} ${startOffset} ${endOffset}`);
+    return false;
 }
 exports.replaceSourceRange = replaceSourceRange;
 function replaceRange(segments, startOffset, endOffset, ...newSegments) {
@@ -94,14 +112,18 @@ function replaceRange(segments, startOffset, endOffset, ...newSegments) {
         inserts.push(trimSegmentStart(endSegment, endOffset - endSegmentStart));
     }
     combineStrings(inserts);
+    (0, track_1.offsetStack)();
     segments.splice(startIndex, endIndex - startIndex + 1, ...inserts);
+    (0, track_1.resetOffsetStack)();
 }
 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') {
             segments[i - 1] = segments[i - 1] + segments[i];
+            (0, track_1.offsetStack)();
             segments.splice(i, 1);
+            (0, track_1.resetOffsetStack)();
         }
     }
 }

package/out/track.d.ts

@@ -0,0 +1,5 @@
+import { Segment, StackNode } from "./types";
+export declare function setTracking(value: boolean): void;
+export declare function offsetStack(): void;
+export declare function resetOffsetStack(): void;
+export declare function track<T extends Segment<any>[]>(segments: T): [T, StackNode[]];

package/out/track.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.track = exports.resetOffsetStack = exports.offsetStack = exports.setTracking = void 0;
+let tracking = true;
+let stackOffset = 0;
+function setTracking(value) {
+    tracking = value;
+}
+exports.setTracking = setTracking;
+function offsetStack() {
+    stackOffset++;
+}
+exports.offsetStack = offsetStack;
+function resetOffsetStack() {
+    stackOffset--;
+}
+exports.resetOffsetStack = resetOffsetStack;
+function track(segments) {
+    const stacks = [];
+    return [
+        new Proxy(segments, {
+            get(target, prop, receiver) {
+                if (tracking) {
+                    if (prop === 'push')
+                        return push;
+                    if (prop === 'pop')
+                        return pop;
+                    if (prop === 'shift')
+                        return shift;
+                    if (prop === 'unshift')
+                        return unshift;
+                    if (prop === 'splice')
+                        return splice;
+                    if (prop === 'sort')
+                        return sort;
+                    if (prop === 'reverse')
+                        return reverse;
+                }
+                return Reflect.get(target, prop, receiver);
+            }
+        }),
+        stacks,
+    ];
+    function push(...items) {
+        stacks.push({ stack: getStack(), length: items.length });
+        return segments.push(...items);
+    }
+    function pop() {
+        if (stacks.length) {
+            const last = stacks[stacks.length - 1];
+            if (last.length > 1) {
+                last.length--;
+            }
+            else {
+                stacks.pop();
+            }
+        }
+        return segments.pop();
+    }
+    function shift() {
+        if (stacks.length) {
+            const first = stacks[0];
+            if (first.length > 1) {
+                first.length--;
+            }
+            else {
+                stacks.shift();
+            }
+        }
+        return segments.shift();
+    }
+    function unshift(...items) {
+        stacks.unshift({ stack: getStack(), length: items.length });
+        return segments.unshift(...items);
+    }
+    function splice(start, deleteCount, ...items) {
+        if (deleteCount === undefined) {
+            deleteCount = segments.length - start;
+        }
+        let remainDeleteCount = deleteCount;
+        let stacksDeleteStart;
+        let stacksDeleteLength = 0;
+        let stackEnd = 0;
+        for (let i = 0; i < stacks.length; i++) {
+            const stack = stacks[i];
+            const stackStart = stackEnd;
+            stackEnd = stackStart + stack.length;
+            while (start >= stackStart && start < stackEnd && remainDeleteCount && stack.length) {
+                stack.length--;
+                remainDeleteCount--;
+                stackEnd--;
+            }
+            if (!stack.length) {
+                stacksDeleteStart !== null && stacksDeleteStart !== void 0 ? stacksDeleteStart : (stacksDeleteStart = i);
+                stacksDeleteLength++;
+            }
+            if (remainDeleteCount <= 0)
+                break;
+        }
+        if (stacksDeleteStart !== undefined) {
+            stacks.splice(stacksDeleteStart, stacksDeleteLength);
+        }
+        return segments.splice(start, deleteCount, ...items);
+    }
+    function sort(compareFn) {
+        stacks.splice(0, stacks.length, { stack: getStack(), length: segments.length });
+        return segments.sort(compareFn);
+    }
+    function reverse() {
+        stacks.splice(0, stacks.length, { stack: getStack(), length: segments.length });
+        return segments.reverse();
+    }
+    function getStack() {
+        const stack = new Error().stack;
+        let source = stack.split('\n')[3 + stackOffset].trim();
+        if (source.endsWith(')')) {
+            source = source.slice(source.lastIndexOf('(') + 1, -1);
+        }
+        else {
+            source = source.slice(source.lastIndexOf(' ') + 1);
+        }
+        return source;
+    }
+}
+exports.track = track;
+//# sourceMappingURL=track.js.map

package/out/types.d.ts

@@ -0,0 +1,16 @@
+declare const NO_DATA_SYMBOL: unique symbol;
+export type Segment<T = typeof NO_DATA_SYMBOL> = string | (T extends typeof NO_DATA_SYMBOL ? [
+    string,
+    string | undefined,
+    number | [number, number]
+] : [
+    string,
+    string | undefined,
+    number | [number, number],
+    T
+]);
+export interface StackNode {
+    length: number;
+    stack: string;
+}
+export {};

package/out/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

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