@rebasepro/plugin-ai 0.12.0 → 0.12.1-canary.g009ed95

package/src/tests/diffStrings.test.ts

@@ -1,128 +0,0 @@
-// Import the diffStrings function from your module
-// import { diffStrings } from './your-module';
-
-import { Change, diffStrings } from "../utils/diffStrings";
-
-describe("diffStrings", () => {
-    test("equal strings", () => {
-        const oldStr = "This is a test string";
-        const newStr = "This is a test string";
-        const expected: Change[] = [
-            {
-                type: "equal",
-                value: "This is a test string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-
-    test("insertions only", () => {
-        const oldStr = "This is a test string";
-        const newStr = "This is a new test string";
-        const expected: Change[] = [
-            {
-                type: "equal",
-                value: "This is a"
-            },
-            {
-                type: "insert",
-                value: " new"
-            },
-            {
-                type: "equal",
-                value: " test string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-
-    test("deletions only", () => {
-        const oldStr = "This is an old test string";
-        const newStr = "This is a test string";
-        const expected: Change[] = [
-            {
-                type: "equal",
-                value: "This is a"
-            },
-            {
-                type: "delete",
-                value: "n old"
-            },
-            {
-                type: "equal",
-                value: " test string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-
-    test("insertions and deletions", () => {
-        const oldStr = "This is an old test string";
-        const newStr = "This is a new modified test string";
-        // The LCS algorithm finds the longest common substrings correctly
-        // Even though the output is more granular, it correctly represents the diff
-        const expected: Change[] = [
-            {
-                type: "equal",
-                value: "This is a"
-            },
-            {
-                type: "insert",
-                value: " "
-            },
-            {
-                type: "equal",
-                value: "n"
-            },
-            {
-                type: "insert",
-                value: "ew"
-            },
-            {
-                type: "equal",
-                value: " "
-            },
-            {
-                type: "insert",
-                value: "m"
-            },
-            {
-                type: "equal",
-                value: "o"
-            },
-            {
-                type: "delete",
-                value: "l"
-            },
-            {
-                type: "insert",
-                value: "difie"
-            },
-            {
-                type: "equal",
-                value: "d test string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-
-    test("completely different strings", () => {
-        const oldStr = "Old string";
-        const newStr = "New string";
-        const expected: Change[] = [
-            {
-                type: "delete",
-                value: "Old"
-            },
-            {
-                type: "insert",
-                value: "New"
-            },
-            {
-                type: "equal",
-                value: " string"
-            }
-        ];
-        expect(diffStrings(oldStr, newStr)).toEqual(expected);
-    });
-});

package/src/tests/strings_counter.test.ts

@@ -1,117 +0,0 @@
-import { countStringCharacters } from "../utils/strings_counter";
-import type { Properties } from "@rebasepro/types";
-
-describe("countStringCharacters", () => {
-    it("counts characters in a string property", () => {
-        const values = { title: "Hello World" };
-        const properties: Properties = {
-            title: { name: "title",
-type: "string" }
-        };
-        expect(countStringCharacters(values, properties)).toBe(11);
-    });
-
-    it("counts characters in a number property (stringified)", () => {
-        const values = { price: 12345 };
-        const properties: Properties = {
-            price: { name: "price",
-type: "number" }
-        };
-        expect(countStringCharacters(values, properties)).toBe(5);
-    });
-
-    it("skips disabled properties", () => {
-        const values = { title: "Hello",
-hidden: "Secret" };
-        const properties: Properties = {
-            title: { name: "title",
-type: "string" },
-            hidden: { name: "hidden",
-type: "string",
-admin: { disabled: true } }
-        };
-        expect(countStringCharacters(values, properties)).toBe(5);
-    });
-
-    it("counts array of strings", () => {
-        const values = { tags: ["hello", "world", "test"] };
-        const properties: Properties = {
-            tags: {
-                name: "tags",
-                type: "array",
-                of: { name: "tag",
-type: "string" }
-            }
-        };
-        // "hello" (5) + "world" (5) + "test" (4) = 14
-        expect(countStringCharacters(values, properties)).toBe(14);
-    });
-
-    it("recurses into map properties", () => {
-        const values = {
-            address: { city: "New York",
-country: "USA" }
-        };
-        const properties: Properties = {
-            address: {
-                name: "address",
-                type: "map",
-                properties: {
-                    city: { name: "city",
-type: "string" },
-                    country: { name: "country",
-type: "string" }
-                }
-            }
-        };
-        // "New York" (8) + "USA" (3) = 11
-        expect(countStringCharacters(values, properties)).toBe(11);
-    });
-
-    it("returns 0 for empty values", () => {
-        const properties: Properties = {
-            title: { name: "title",
-type: "string" }
-        };
-        expect(countStringCharacters({}, properties)).toBe(0);
-    });
-
-    it("handles mixed property types", () => {
-        const values = {
-            title: "Hello",
-            count: 42,
-            active: true,
-            tags: ["a", "bb"]
-        };
-        const properties: Properties = {
-            title: { name: "title",
-type: "string" },
-            count: { name: "count",
-type: "number" },
-            active: { name: "active",
-type: "boolean" },
-            tags: {
-                name: "tags",
-                type: "array",
-                of: { name: "tag",
-type: "string" }
-            }
-        };
-        // "Hello" (5) + "42" (2) + "a" (1) + "bb" (2) = 10
-        expect(countStringCharacters(values, properties)).toBe(10);
-    });
-
-    it("handles null values in array gracefully", () => {
-        const values = { tags: [null, "hello", null] };
-        const properties: Properties = {
-            tags: {
-                name: "tags",
-                type: "array",
-                of: { name: "tag",
-type: "string" }
-            }
-        };
-        // null?.length = 0, "hello" = 5, null?.length = 0
-        expect(countStringCharacters(values, properties)).toBe(5);
-    });
-});

package/src/tests/suggestions.test.ts

@@ -1,53 +0,0 @@
-import { getAppendableSuggestion } from "../utils/suggestions";
-
-describe("getAppendableSuggestion", () => {
-    it("returns the remaining part when suggestion starts with value", () => {
-        const result = getAppendableSuggestion("Hello World", "Hello");
-        expect(result).toBe(" World");
-    });
-
-    it("returns undefined when suggestion does not start with value", () => {
-        const result = getAppendableSuggestion("Goodbye World", "Hello");
-        expect(result).toBeUndefined();
-    });
-
-    it("performs case-insensitive matching", () => {
-        const result = getAppendableSuggestion("Hello World", "hello");
-        expect(result).toBe(" World");
-    });
-
-    it("returns undefined for number suggestion", () => {
-        const result = getAppendableSuggestion(42, "4");
-        expect(result).toBeUndefined();
-    });
-
-    it("returns undefined for undefined suggestion", () => {
-        const result = getAppendableSuggestion(undefined, "hello");
-        expect(result).toBeUndefined();
-    });
-
-    it("returns undefined for non-string value", () => {
-        const result = getAppendableSuggestion("Hello", 42);
-        expect(result).toBeUndefined();
-    });
-
-    it("returns full suggestion when value is empty string", () => {
-        const result = getAppendableSuggestion("Hello World", "");
-        expect(result).toBe("Hello World");
-    });
-
-    it("handles whitespace trimming", () => {
-        const result = getAppendableSuggestion("Hello World", "Hello");
-        expect(result).toBe(" World");
-    });
-
-    it("returns empty string when suggestion equals value", () => {
-        const result = getAppendableSuggestion("Hello", "Hello");
-        expect(result).toBe("");
-    });
-
-    it("returns undefined when value is longer than suggestion", () => {
-        const result = getAppendableSuggestion("Hi", "Hello World");
-        expect(result).toBeUndefined();
-    });
-});

package/src/utils/diffStrings.ts

@@ -1,70 +0,0 @@
-type ChangeType = "equal" | "delete" | "insert";
-
-export interface Change {
-    type: ChangeType;
-    value: string;
-}
-
-export function diffStrings(oldStr: string, newStr: string): Change[] {
-    // Find the longest common substring
-    function longestCommonSubstring(s1: string, s2: string): string {
-        const longest = { start: 0,
-length: 0 };
-        const matrix = new Array(s1.length + 1).fill(null).map(() => new Array(s2.length + 1).fill(0));
-
-        for (let i = 1; i <= s1.length; i++) {
-            for (let j = 1; j <= s2.length; j++) {
-                if (s1[i - 1] === s2[j - 1]) {
-                    matrix[i][j] = matrix[i - 1][j - 1] + 1;
-                    if (matrix[i][j] > longest.length) {
-                        longest.start = i - matrix[i][j];
-                        longest.length = matrix[i][j];
-                    }
-                }
-            }
-        }
-
-        return s1.slice(longest.start, longest.start + longest.length);
-    }
-
-    // Recursively find changes and create Change objects
-    function findChanges(s1: string, s2: string): Change[] {
-        if (s1 === s2) return s1.length > 0 ? [{
-            type: "equal",
-            value: s1
-        }] : [];
-
-        const common = longestCommonSubstring(s1, s2);
-
-        if (common.length === 0) {
-            const changes: Change[] = [];
-            if (s1.length > 0) {
-                changes.push({ type: "delete",
-value: s1 });
-            }
-            if (s2.length > 0) {
-                changes.push({ type: "insert",
-value: s2 });
-            }
-            return changes;
-        }
-
-        const s1Before = s1.slice(0, s1.indexOf(common));
-        const s1After = s1.slice(s1.indexOf(common) + common.length);
-        const s2Before = s2.slice(0, s2.indexOf(common));
-        const s2After = s2.slice(s2.indexOf(common) + common.length);
-
-        const changesBefore = findChanges(s1Before, s2Before);
-        const changesAfter = findChanges(s1After, s2After);
-
-        return [
-            ...changesBefore,
-            { type: "equal",
-value: common },
-            ...changesAfter
-        ];
-    }
-
-    return findChanges(oldStr, newStr);
-}
-

package/src/utils/strings_counter.ts

@@ -1,22 +0,0 @@
-import { EntityValues, Properties, Property } from "@rebasepro/types";
-
-export function countStringCharacters(values: EntityValues<any>, properties: Properties) {
-    let count = 0;
-
-    for (const key in values) {
-        const value = values[key];
-        const property: Property = properties[key];
-
-        if (property && !property.admin?.disabled) {
-            if (property.type === "string" || property.type === "number") {
-                count += String(value).length;
-            } else if (property.type === "array" && Array.isArray(value) && property.of && !Array.isArray(property.of) && property.of.type === "string") {
-                count += (value as string[]).reduce((acc, curr) => acc + (curr?.length ?? 0), 0);
-            } else if (property.type === "map" && property.properties && typeof value === "object") {
-                count += countStringCharacters(value, property.properties);
-            }
-        }
-    }
-
-    return count;
-}

package/src/utils/suggestions.ts

@@ -1,6 +0,0 @@
-export function getAppendableSuggestion(suggestion: string | number | undefined, value: unknown): string | undefined {
-    const suggestionIncludesValue = typeof suggestion === "string" && typeof value === "string" && suggestion.toLowerCase().trim().startsWith(value.toLowerCase().trim());
-    return (typeof value === "string" && suggestionIncludesValue)
-        ? suggestion.substring(suggestion.toLowerCase().trim().indexOf(value.toLowerCase().trim()) + value.trim().length)
-        : undefined;
-}