@rebasepro/plugin-ai 0.0.1-canary.4829d6e

package/src/utils/properties.ts

@@ -0,0 +1,168 @@
+import { getFieldId } from "@rebasepro/admin";
+import { EnumValues, Properties, Property } from "@rebasepro/types";
+import { isPropertyBuilder } from "@rebasepro/common";
+import { InputProperty } from "../types/data_enhancement_controller";
+import { getValueInPath } from "@rebasepro/utils";
+
+export function getSimplifiedProperties<M extends Record<string, any>>(properties: Properties, values: M, path = ""): Record<string, InputProperty> {
+    if (!properties) return {};
+    return Object.entries(properties)
+        .map(([key, property]) => {
+            if (isPropertyBuilder(property)) return {};
+            const fullKey = path ? `${path}.${key}` : key;
+            const valueInPath = getValueInPath(values, fullKey);
+            return getSimplifiedProperty(property, fullKey, valueInPath)
+        })
+        .reduce((a, b) => ({ ...a,
+...b }), {});
+}
+
+function getSimpleProperty(property: Property): InputProperty {
+    const fieldId = getFieldId(property);
+    if (!fieldId) {
+        console.error("No fieldId found for property", property);
+        throw new Error("Field id not found");
+    }
+    return {
+        name: property.name,
+        description: property.description,
+        type: property.type,
+        fieldConfigId: fieldId,
+        enum: "enum" in property && property.enum
+            ? getSimpleEnumValues(property.enum)
+            : undefined,
+        disabled: Boolean(property.ui?.disabled || property.ui?.readOnly)
+    };
+}
+
+function getSimplifiedProperty(property: Property, path: string, value?: unknown): Record<string, InputProperty> {
+    if (isPropertyBuilder(property)) return {};
+    if (property.type === "array") {
+
+        if (property.of && !Array.isArray(property.of) && !isPropertyBuilder(property.of)) {
+            const arrayParentProperty: InputProperty = {
+                name: property.name,
+                description: property.description,
+                type: property.type,
+                fieldConfigId: "repeat",
+                disabled: Boolean(property.ui?.disabled || property.ui?.readOnly),
+                of: getSimpleProperty(property.of as Property)
+            };
+
+            const result = { [path]: arrayParentProperty };
+            // if (Array.isArray(value)) {
+            //     result = {
+            //         ...result,
+            //         ...value
+            //             .map((v, i) => getSimplifiedProperty(property.of, `${path}.${i}`, v))
+            //             .reduce((a, b) => ({ ...a, ...b }), {})
+            //     };
+            // }
+            //
+            // const existingValuesCount = Array.isArray(value) ? value.length : 0;
+            //
+            // const newValuesCount = property.of && !isPropertyBuilder<any, any>(property.of) && (property.of as Property).type === "map" ? 1 : 3;
+            // result = {
+            //     ...result,
+            //     // ...Array.from(Array(newValuesCount))
+            //     //     .map((v, i) => getSimplifiedProperty(property.of, `${path}.${i + existingValuesCount}`, v))
+            //     //     .reduce((a, b) => ({ ...a, ...b }), {})
+            // }
+
+            return result;
+        } else if (property.oneOf) {
+
+            const arrayParentProperty: InputProperty = {
+                name: property.name,
+                description: property.description,
+                type: property.type,
+                fieldConfigId: "block",
+                disabled: Boolean(property.ui?.disabled || property.ui?.readOnly),
+                oneOf: {
+                    typeField: property.oneOf.typeField,
+                    valueField: property.oneOf.valueField,
+                    properties: Object.entries(property.oneOf.properties)
+                        .map(([key, prop]) => ({ [key]: getSimpleProperty(prop) }))
+                        .reduce((a, b) => ({ ...a,
+...b }), {})
+                }
+            };
+
+            if (!Array.isArray(value)) {
+                return { [path]: arrayParentProperty };
+            }
+
+            return value.map((v, i) => {
+                if (v == null) return {};
+                const typeKey = property.oneOf!.typeField ?? "type";
+                const oneOfType = v[typeKey];
+                const valueKey = property.oneOf!.valueField ?? "value";
+                const oneOfValue = v[valueKey];
+                const childProperty = property.oneOf!.properties[oneOfType];
+                if (childProperty === undefined) {
+                    console.error(`No property found for type ${oneOfType}`, property.oneOf!.properties);
+                    return {};
+                }
+                const simplifiedProperty = getSimplifiedProperty(childProperty, `${path}.${i}.${valueKey}`, oneOfValue);
+                return {
+                    [`${path}.${i}.${typeKey}`]: oneOfType,
+                    ...simplifiedProperty
+                };
+            }).reduce((a, b) => ({ ...a,
+...b }), { [path]: arrayParentProperty });
+        }
+    } else if (property.type === "map") {
+        if (property.properties) {
+            const mapProperties: Record<string, InputProperty> = Object.entries(property.properties)
+                .map(([key, childProperty]) => {
+                    const childValue = value && typeof value === "object" ? (value as Record<string, unknown>)[key] : undefined;
+                    return getSimplifiedProperty(childProperty, key, childValue);
+                })
+                .map(o => attachPathToKeys(o, path))
+                .reduce((a, b) => ({ ...a,
+...b }), {});
+
+            if (Object.keys(mapProperties).length === 0) return {};
+            const mapParentProperty: InputProperty = {
+                name: property.name,
+                description: property.description,
+                type: property.type,
+                fieldConfigId: "group",
+                disabled: Boolean(property.ui?.disabled || property.ui?.readOnly)
+            };
+            return {
+                [path]: mapParentProperty,
+                ...mapProperties
+            } as Record<string, InputProperty>;
+        }
+    } else {
+        const fieldId = getFieldId(property);
+        if (!fieldId) {
+            console.warn(`No fieldId found for property ${path} with type ${property.type}`);
+            return {};
+        }
+        return {
+            [path]: getSimpleProperty(property)
+        };
+    }
+    return {};
+}
+
+// attach a path to every key in an object
+function attachPathToKeys(obj: Record<string, InputProperty>, path = ""): Record<string, InputProperty> {
+    return Object.entries(obj)
+        .map(([key, value]) => {
+            const fullKey = path ? `${path}.${key}` : key;
+            return { [fullKey]: value };
+        })
+        .reduce((a, b) => ({ ...a,
+...b }), {});
+}
+
+function getSimpleEnumValues(enumValues: EnumValues): string[] {
+    if (Array.isArray(enumValues))
+        return enumValues.map(v => String(v.id));
+    if (typeof enumValues === "object")
+        return Object.keys(enumValues);
+    throw Error("getSimpleEnumValues: Invalid enumValues");
+}

package/src/utils/strings_counter.ts

@@ -0,0 +1,22 @@
+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.ui?.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

@@ -0,0 +1,6 @@
+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;
+}

package/src/utils/values.ts

@@ -0,0 +1,12 @@
+export function flatMapEntityValues<M extends object>(values: M, path = ""): object {
+    if (!values) return {};
+    return Object.entries(values).flatMap(([key, value]) => {
+        const currentPath = path ? `${path}.${key}` : key;
+        if (typeof value === "object") {
+            return flatMapEntityValues(value, currentPath);
+        } else {
+            return { [currentPath]: value };
+        }
+    }).reduce((acc, curr) => ({ ...acc,
+...curr }), {})
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />