@character-foundry/character-foundry 0.1.5 → 0.1.7

package/dist/app-framework.cjs

@@ -408,13 +408,23 @@ function analyzeField(name, zodType) {
     constraints: extractConstraints(currentType)
   };
 }
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeKey(key) {
+  return !DANGEROUS_KEYS.has(key);
+}
 function getValueAtPath(obj, path) {
   const parts = path.split(".");
   let current = obj;
   for (const part of parts) {
+    if (!isSafeKey(part)) {
+      return void 0;
+    }
     if (current == null || typeof current !== "object") {
       return void 0;
     }
+    if (!Object.hasOwn(current, part)) {
+      return void 0;
+    }
     current = current[part];
   }
   return current;
@@ -424,12 +434,16 @@ function setValueAtPath(obj, path, value) {
   if (parts.length === 0 || parts[0] === void 0) {
     return obj;
   }
+  const first = parts[0];
+  if (!isSafeKey(first)) {
+    console.warn(`Rejected dangerous property key in path: ${first}`);
+    return obj;
+  }
   if (parts.length === 1) {
-    return { ...obj, [parts[0]]: value };
+    return { ...obj, [first]: value };
   }
-  const first = parts[0];
   const rest = parts.slice(1);
-  const nested = obj[first] ?? {};
+  const nested = (Object.hasOwn(obj, first) ? obj[first] : {}) ?? {};
   return {
     ...obj,
     [first]: setValueAtPath(nested, rest.join("."), value)
@@ -821,11 +835,31 @@ function SearchableSelect({
   const [isOpen, setIsOpen] = (0, import_react3.useState)(false);
   const [searchTerm, setSearchTerm] = (0, import_react3.useState)("");
   const [highlightedIndex, setHighlightedIndex] = (0, import_react3.useState)(-1);
-  const options = hint?.options ?? [];
-  const filteredOptions = searchTerm ? options.filter(
-    (opt) => opt.label.toLowerCase().includes(searchTerm.toLowerCase()) || opt.value.toLowerCase().includes(searchTerm.toLowerCase())
-  ) : options;
-  const selectedOption = options.find((opt) => opt.value === value);
+  const rawOptions = hint?.options ?? [];
+  const indexedOptions = (0, import_react3.useMemo)(() => {
+    return rawOptions.map((opt) => ({
+      option: opt,
+      labelLower: opt.label.toLowerCase(),
+      valueLower: opt.value.toLowerCase()
+    }));
+  }, [rawOptions]);
+  const optionsByValue = (0, import_react3.useMemo)(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const opt of rawOptions) {
+      map.set(opt.value, opt);
+    }
+    return map;
+  }, [rawOptions]);
+  const filteredOptions = (0, import_react3.useMemo)(() => {
+    if (!searchTerm) {
+      return rawOptions;
+    }
+    const searchLower = searchTerm.toLowerCase();
+    return indexedOptions.filter(
+      (indexed) => indexed.labelLower.includes(searchLower) || indexed.valueLower.includes(searchLower)
+    ).map((indexed) => indexed.option);
+  }, [searchTerm, indexedOptions, rawOptions]);
+  const selectedOption = optionsByValue.get(value ?? "");
   const displayValue = selectedOption?.label ?? value ?? "";
   (0, import_react3.useEffect)(() => {
     function handleClickOutside(e) {
@@ -1466,33 +1500,84 @@ function AutoForm({
     extractDefaults(fieldInfoMap);
     return defaults;
   }, [fieldInfoMap]);
+  const mergedDefaults = (0, import_react.useMemo)(() => {
+    return deepMerge(
+      deepMerge(schemaDefaults, defaultValues ?? {}),
+      values ?? {}
+    );
+  }, [schemaDefaults, defaultValues, values]);
   const methods = (0, import_react_hook_form.useForm)({
     resolver: (0, import_zod2.zodResolver)(schema),
-    defaultValues: {
-      ...schemaDefaults,
-      ...defaultValues,
-      ...values
-    },
+    defaultValues: mergedDefaults,
     mode: "onChange",
     shouldUnregister: true
   });
-  const { control, handleSubmit, watch, formState, reset } = methods;
-  const watchedValues = watch();
+  const { control, handleSubmit, watch, formState, reset, getValues } = methods;
   const prevValuesRef = (0, import_react.useRef)(values);
+  const conditionFields = (0, import_react.useMemo)(() => {
+    const fields = /* @__PURE__ */ new Set();
+    const extractConditionFields = (hints, prefix = "") => {
+      for (const [key, value] of Object.entries(hints)) {
+        if (!value || typeof value !== "object") continue;
+        const hint = value;
+        if (hint.condition && typeof hint.condition === "object") {
+          const condition = hint.condition;
+          if (condition.field) {
+            fields.add(condition.field);
+          }
+        }
+        if (!("widget" in hint) && !("label" in hint) && !("condition" in hint)) {
+          extractConditionFields(hint, prefix ? `${prefix}.${key}` : key);
+        }
+      }
+    };
+    extractConditionFields(uiHints);
+    return Array.from(fields);
+  }, [uiHints]);
+  const [conditionValues, setConditionValues] = (0, import_react.useState)({});
+  (0, import_react.useEffect)(() => {
+    if (conditionFields.length === 0) return;
+    const initial = {};
+    const currentValues = getValues();
+    for (const field of conditionFields) {
+      initial[field] = getValueAtPath(currentValues, field);
+    }
+    setConditionValues(initial);
+    const subscription = watch((formValues, { name }) => {
+      if (name && conditionFields.includes(name)) {
+        setConditionValues((prev) => ({
+          ...prev,
+          [name]: getValueAtPath(formValues, name)
+        }));
+      }
+    });
+    return () => subscription.unsubscribe();
+  }, [conditionFields, watch, getValues]);
   (0, import_react.useEffect)(() => {
     if (values && !shallowEqual(values, prevValuesRef.current)) {
       prevValuesRef.current = values;
-      reset({ ...schemaDefaults, ...defaultValues, ...values });
+      const resetValues = deepMerge(
+        deepMerge(schemaDefaults, defaultValues ?? {}),
+        values ?? {}
+      );
+      reset(resetValues);
     }
   }, [values, reset, schemaDefaults, defaultValues]);
+  const onChangeRef = (0, import_react.useRef)(onChange);
+  onChangeRef.current = onChange;
+  const schemaRef = (0, import_react.useRef)(schema);
+  schemaRef.current = schema;
   (0, import_react.useEffect)(() => {
-    if (onChange) {
-      const result = schema.safeParse(watchedValues);
-      if (result.success) {
-        onChange(result.data);
+    if (!onChangeRef.current) return;
+    const subscription = watch((formValues, { type }) => {
+      if (type !== "change") return;
+      const result = schemaRef.current.safeParse(formValues);
+      if (result.success && onChangeRef.current) {
+        onChangeRef.current(result.data);
       }
-    }
-  }, [watchedValues, onChange, schema]);
+    });
+    return () => subscription.unsubscribe();
+  }, [watch]);
   const HINT_KEYS = /* @__PURE__ */ new Set([
     "widget",
     "label",
@@ -1538,9 +1623,9 @@ function AutoForm({
   const isConditionMet = (0, import_react.useCallback)(
     (condition) => {
       if (!condition) return true;
-      const fieldValue = getValueAtPath(watchedValues, condition.field);
+      const fieldValue = conditionFields.length > 0 ? conditionValues[condition.field] : getValueAtPath(getValues(), condition.field);
       if (condition.when) {
-        return condition.when(fieldValue, watchedValues);
+        return condition.when(fieldValue, getValues());
       }
       if ("equals" in condition && condition.equals !== void 0) {
         return fieldValue === condition.equals;
@@ -1556,7 +1641,7 @@ function AutoForm({
       }
       return true;
     },
-    [watchedValues]
+    [conditionFields, conditionValues, getValues]
   );
   const orderedFields = (0, import_react.useMemo)(() => {
     if (fieldOrder) {
@@ -1650,19 +1735,51 @@ function AutoForm({
   }
   return formContent;
 }
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    if (!isSafeKey2(key)) continue;
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (isPlainObject(baseVal) && isPlainObject(overrideVal)) {
+      result[key] = deepMerge(
+        baseVal,
+        overrideVal
+      );
+    } else if (overrideVal !== void 0) {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function isPlainObject(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
+}
+var DANGEROUS_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeKey2(key) {
+  return !DANGEROUS_KEYS2.has(key);
+}
 function setNestedValue(obj, path, value) {
   const parts = path.split(".");
   let current = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const part = parts[i];
     if (part === void 0) continue;
-    if (!(part in current) || typeof current[part] !== "object") {
+    if (!isSafeKey2(part)) {
+      console.warn(`Rejected dangerous property key in path: ${part}`);
+      return;
+    }
+    if (!Object.hasOwn(current, part) || typeof current[part] !== "object") {
       current[part] = {};
     }
     current = current[part];
   }
   const lastPart = parts[parts.length - 1];
   if (lastPart !== void 0) {
+    if (!isSafeKey2(lastPart)) {
+      console.warn(`Rejected dangerous property key in path: ${lastPart}`);
+      return;
+    }
     current[lastPart] = value;
   }
 }