@rebasepro/plugin-data-enhancement 0.2.3 → 0.2.4

package/src/tests/suggestions.test.ts

@@ -0,0 +1,53 @@
+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/tests/values.test.ts

@@ -0,0 +1,83 @@
+import { flatMapEntityValues } from "../utils/values";
+
+describe("flatMapEntityValues", () => {
+    it("returns flat object unchanged", () => {
+        const values = { name: "John", age: 30 };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({ name: "John", age: 30 });
+    });
+
+    it("flattens nested object to dot-notation keys", () => {
+        const values = {
+            address: { city: "NYC", zip: "10001" }
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({
+            "address.city": "NYC",
+            "address.zip": "10001"
+        });
+    });
+
+    it("flattens deeply nested objects", () => {
+        const values = {
+            a: { b: { c: { d: "deep" } } }
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({ "a.b.c.d": "deep" });
+    });
+
+    it("returns empty object for empty input", () => {
+        expect(flatMapEntityValues({})).toEqual({});
+    });
+
+    it("returns empty object for null input", () => {
+        expect(flatMapEntityValues(null as unknown as object)).toEqual({});
+    });
+
+    it("returns empty object for undefined input", () => {
+        expect(flatMapEntityValues(undefined as unknown as object)).toEqual({});
+    });
+
+    it("handles mixed nested and flat values", () => {
+        const values = {
+            name: "John",
+            address: { city: "NYC" },
+            active: true
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({
+            name: "John",
+            "address.city": "NYC",
+            active: true
+        });
+    });
+
+    it("handles multiple nested objects", () => {
+        const values = {
+            home: { city: "NYC" },
+            work: { city: "SF" }
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({
+            "home.city": "NYC",
+            "work.city": "SF"
+        });
+    });
+
+    it("handles numeric values in nested objects", () => {
+        const values = {
+            stats: { visits: 100, clicks: 50 }
+        };
+        const result = flatMapEntityValues(values);
+        expect(result).toEqual({
+            "stats.visits": 100,
+            "stats.clicks": 50
+        });
+    });
+
+    it("uses custom path prefix", () => {
+        const values = { name: "John" };
+        const result = flatMapEntityValues(values, "user");
+        expect(result).toEqual({ "user.name": "John" });
+    });
+});

package/src/utils/properties.ts

@@ -35,7 +35,7 @@ function getSimpleProperty(property: Property): InputProperty {
     };
 }
 
-function getSimplifiedProperty(property: Property, path: string, value?: any): Record<string, InputProperty> {
+function getSimplifiedProperty(property: Property, path: string, value?: unknown): Record<string, InputProperty> {
     if (isPropertyBuilder(property)) return {};
     if (property.type === "array") {
 
@@ -115,7 +115,7 @@ function getSimplifiedProperty(property: Property, path: string, value?: any): R
         if (property.properties) {
             const mapProperties: Record<string, InputProperty> = Object.entries(property.properties)
                 .map(([key, childProperty]) => {
-                    const childValue = value?.[key];
+                    const childValue = value && typeof value === "object" ? (value as Record<string, unknown>)[key] : undefined;
                     return getSimplifiedProperty(childProperty, key, childValue);
                 })
                 .map(o => attachPathToKeys(o, path))
@@ -149,7 +149,7 @@ function getSimplifiedProperty(property: Property, path: string, value?: any): R
 }
 
 // attach a path to every key in an object
-function attachPathToKeys(obj: Record<string, any>, path = ""): Record<string, any> {
+function attachPathToKeys(obj: Record<string, InputProperty>, path = ""): Record<string, InputProperty> {
     return Object.entries(obj)
         .map(([key, value]) => {
             const fullKey = path ? `${path}.${key}` : key;

package/src/utils/suggestions.ts

@@ -1,4 +1,4 @@
-export function getAppendableSuggestion(suggestion: string | number | undefined, value: any): string | undefined {
+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)

package/dist/admin/src/collection_editor/types/config_permissions.d.ts

@@ -1,19 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-export type CollectionEditorPermissionsBuilder<USER = any, EC extends EntityCollection = EntityCollection> = (params: {
-    user: USER | null;
-    collection?: EC;
-}) => CollectionEditorPermissions;
-export type CollectionEditorPermissions = {
-    /**
-     * Is the user allowed to create new collections.
-     */
-    createCollections: boolean;
-    /**
-     * Is the user allowed to modify this collection
-     */
-    editCollections: boolean;
-    /**
-     * Is the user allowed to delete this collection
-     */
-    deleteCollections: boolean;
-};

package/dist/admin/src/components/admin/UsersView.d.ts

@@ -1,4 +0,0 @@
-import { UserManagementDelegate } from "@rebasepro/types";
-export declare function UsersView({ userManagement }: {
-    userManagement: UserManagementDelegate;
-}): import("react/jsx-runtime").JSX.Element;

package/dist/core/src/hooks/useValidateAuthenticator.d.ts

@@ -1,21 +0,0 @@
-import { AuthController, Authenticator, RebaseData, StorageSource, User } from "@rebasepro/types";
-/**
- * This hook is used internally for validating an authenticator.
- *
- * @param authController
- * @param authentication
- * @param storageSource
- * @param data
- */
-export declare function useValidateAuthenticator<USER extends User = any>({ disabled, authController, authenticator, storageSource, data }: {
-    disabled?: boolean;
-    authController: AuthController<USER>;
-    authenticator?: boolean | Authenticator<USER>;
-    data: RebaseData;
-    storageSource: StorageSource;
-}): {
-    canAccessMainView: boolean;
-    authLoading: boolean;
-    notAllowedError: any;
-    authVerified: boolean;
-};

package/dist/core/src/util/icon_synonyms.d.ts

@@ -1 +0,0 @@
-export declare const iconSynonyms: Record<string, string>;

package/dist/core/src/util/useTraceUpdate.d.ts

@@ -1,2 +0,0 @@
-export declare function printChanged(props: any, prev: any, path?: string | undefined, depth?: number | undefined, maxDepth?: number | undefined): void;
-export declare function useTraceUpdate(props: any, maxDepth?: number): void;

package/dist/plugin-data-enhancement/src/types/subscriptions_message_props.d.ts

@@ -1,3 +0,0 @@
-export type SubscriptionMessageProps = {
-    projectId: string;
-};

package/src/types/subscriptions_message_props.tsx

@@ -1 +0,0 @@
-export type SubscriptionMessageProps = { projectId: string };