@resistdesign/voltra 3.0.0-alpha.3 → 3.0.0-alpha.30

package/app/index.js

@@ -0,0 +1,560 @@
+import '../chunk-MUCSL3UR.js';
+export { createEasyLayout, getEasyLayoutTemplateDetails, getPascalCaseAreaName } from '../chunk-FQMZMCXU.js';
+export { Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, buildHistoryPath, buildQueryString, buildRoutePath, canUseBrowserHistory, computeTrackPixels, createBrowserRouteAdapter, createHistoryBackHandler, createManualRouteAdapter, createMemoryHistory, createNativeRouteAdapter, createRouteAdapterFromHistory, createUniversalAdapter, parseHistoryPath, useRouteContext } from '../chunk-G5CLUK4Y.js';
+export { AutoForm, AutoFormView, computeAreaBounds, createAutoField, createFormRenderer, getFieldKind, parseTemplate, resolveSuite, useFormEngine, validateAreas } from '../chunk-WELZGQDJ.js';
+import '../chunk-HVY7POTD.js';
+import '../chunk-IWRHGGGH.js';
+import { mergeStringPaths, PATH_DELIMITER } from '../chunk-GYWRAW3Y.js';
+import '../chunk-I2KLQ2HA.js';
+import { createContext, useContext, useRef, useMemo, useCallback, useState, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var getApplicationStateIdentifier = (subStateIdMap) => subStateIdMap ? subStateIdMap : {};
+var getApplicationStateModified = (identifier, modificationState) => !!modificationState.get(identifier);
+var getApplicationStateValue = (identifier, applicationState) => applicationState.get(identifier);
+var setApplicationStateModified = (identifier, value, modificationState) => new Map(modificationState).set(identifier, value);
+var setApplicationStateValue = (identifier, value, applicationState) => new Map(applicationState).set(identifier, value);
+var getApplicationStateValueStructure = (idStructure, applicationState) => Object.keys(idStructure).reduce(
+  (acc, k) => ({
+    ...acc,
+    [k]: getApplicationStateValue(idStructure[k], applicationState)
+  }),
+  {}
+);
+var ApplicationStateContext = createContext({
+  modified: /* @__PURE__ */ new Map(),
+  value: /* @__PURE__ */ new Map(),
+  onChange: () => {
+  },
+  setModified: () => {
+  }
+});
+var { Provider } = ApplicationStateContext;
+var useApplicationStateValue = (identifier) => {
+  const {
+    modified: modificationState,
+    value: applicationState,
+    onChange: setApplicationState,
+    setModified: setModificationState
+  } = useContext(ApplicationStateContext);
+  const appStateRef = useRef(applicationState);
+  appStateRef.current = applicationState;
+  const modified = useMemo(
+    () => getApplicationStateModified(identifier, modificationState),
+    [identifier, modificationState]
+  );
+  const value = useMemo(
+    () => getApplicationStateValue(identifier, applicationState),
+    [identifier, applicationState]
+  );
+  const setModified = useCallback(
+    (isModified) => {
+      setModificationState(
+        setApplicationStateModified(identifier, isModified, modificationState)
+      );
+    },
+    [identifier, setModificationState]
+  );
+  const onChange = useCallback(
+    (newValue) => {
+      setApplicationState(
+        setApplicationStateValue(identifier, newValue, appStateRef.current)
+      );
+      setModified(true);
+    },
+    [identifier, setApplicationState]
+  );
+  const controller = useMemo(
+    () => ({
+      modified,
+      value,
+      onChange,
+      setModified
+    }),
+    [modified, onChange, setModified, value]
+  );
+  return controller;
+};
+var useApplicationStateValueStructure = (idStructure) => {
+  const { value: applicationState, onChange: setApplicationState } = useContext(
+    ApplicationStateContext
+  );
+  const valueStructure = useMemo(
+    () => getApplicationStateValueStructure(idStructure, applicationState),
+    [applicationState, idStructure]
+  );
+  const onChangeStructure = useMemo(
+    () => Object.keys(idStructure).reduce(
+      (acc, k) => ({
+        ...acc,
+        [k]: (newValue) => {
+          setApplicationState(
+            setApplicationStateValue(
+              idStructure[k],
+              newValue,
+              applicationState
+            )
+          );
+        }
+      }),
+      {}
+    ),
+    [applicationState, idStructure, setApplicationState]
+  );
+  const controller = useMemo(
+    () => ({
+      valueStructure,
+      onChangeStructure
+    }),
+    [onChangeStructure, valueStructure]
+  );
+  return controller;
+};
+var ApplicationStateProvider = ({
+  children
+}) => {
+  const [modified, setModified] = useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [value, setValue] = useState(/* @__PURE__ */ new Map());
+  const controller = useMemo(
+    () => ({
+      modified,
+      value,
+      onChange: setValue,
+      setModified
+    }),
+    [modified, value]
+  );
+  return /* @__PURE__ */ jsx(Provider, { value: controller, children });
+};
+
+// src/app/utils/Service.ts
+var getFullUrl = (protocol, domain, basePath = "", path = "", port) => {
+  const portString = !!port ? `:${port}` : "";
+  const fullPath = mergeStringPaths(
+    basePath,
+    path,
+    PATH_DELIMITER,
+    false,
+    false,
+    false
+  );
+  return `${protocol}://${domain}${portString}${fullPath}`;
+};
+var sendServiceRequest = async (config, path = "", args = []) => {
+  const { protocol, domain, port, basePath = "", authorization = "" } = config;
+  const fullUrl = getFullUrl(protocol, domain, basePath, path, port);
+  const requestHeaders = {
+    "Content-Type": "application/json",
+    ...!!authorization ? {
+      Authorization: `Bearer ${authorization}`
+    } : {}
+  };
+  const response = await fetch(fullUrl, {
+    headers: requestHeaders,
+    credentials: "same-origin",
+    method: "POST",
+    body: JSON.stringify(args)
+  });
+  const { ok: responseIsOk } = response;
+  const data = await response.json();
+  if (responseIsOk) {
+    return data;
+  } else {
+    throw data;
+  }
+};
+var useApplicationStateLoader = (config) => {
+  const {
+    identifier,
+    remoteProcedureCall,
+    resetOnError = false,
+    onLoadComplete,
+    manual = false
+  } = config;
+  const { args = [] } = remoteProcedureCall;
+  const argsRef = useRef(args);
+  argsRef.current = args;
+  const [cacheValidity, setCacheValidity] = useState({});
+  const [loading, setLoading] = useState(false);
+  const [latestError, setLatestError] = useState();
+  const { onChange, setModified } = useApplicationStateValue(identifier);
+  const invalidate = useCallback(() => {
+    setCacheValidity({});
+  }, []);
+  const makeRemoteProcedureCall = useCallback(
+    async (...directArgs) => {
+      let success;
+      setLoading(true);
+      setLatestError(void 0);
+      try {
+        const { serviceConfig, path } = remoteProcedureCall;
+        const result = await sendServiceRequest(
+          serviceConfig,
+          path,
+          directArgs
+        );
+        success = true;
+        onChange(result);
+        setModified(false);
+      } catch (error) {
+        success = false;
+        setLatestError(error);
+        if (resetOnError) {
+          onChange(void 0);
+          setModified(false);
+        }
+      }
+      setLoading(false);
+      onLoadComplete?.(success);
+    },
+    [remoteProcedureCall, onChange, setModified, resetOnError, onLoadComplete]
+  );
+  const appStateLoader = useMemo(
+    () => ({
+      loading,
+      latestError,
+      invalidate,
+      makeRemoteProcedureCall
+    }),
+    [loading, latestError, invalidate, makeRemoteProcedureCall]
+  );
+  useEffect(() => {
+    if (!manual && argsRef.current) {
+      makeRemoteProcedureCall(...argsRef.current);
+    }
+  }, [cacheValidity, manual, makeRemoteProcedureCall]);
+  return appStateLoader;
+};
+var getKeyValueWithoutError = (obj, key) => {
+  try {
+    return obj[key];
+  } catch (e) {
+    return void 0;
+  }
+};
+var useController = (parentValue, key, onParentValueChange, isArrayIndex = false) => {
+  const [value, setValue] = useState(getKeyValueWithoutError(parentValue, key));
+  const onChange = useCallback(
+    (value2) => {
+      try {
+        setValue(value2);
+        if (isArrayIndex) {
+          const newArray = [...parentValue];
+          newArray[key] = value2;
+          onParentValueChange(newArray);
+        } else {
+          onParentValueChange({
+            ...parentValue,
+            [key]: value2
+          });
+        }
+      } catch (e) {
+      }
+    },
+    [parentValue, key, onParentValueChange, isArrayIndex]
+  );
+  useEffect(() => {
+    try {
+      setValue(getKeyValueWithoutError(parentValue, key));
+    } catch (e) {
+      setValue(void 0);
+    }
+  }, [parentValue, key]);
+  return [value, onChange];
+};
+var getChangedDependencyIndexes = (prevDeps, nextDeps) => nextDeps.map((dep, i) => dep !== prevDeps[i] ? i : null).filter((dep) => dep !== null);
+var useDebugDependencies = (dependencies) => {
+  const firstRender = useRef(true);
+  const prevDeps = useRef(dependencies);
+  useEffect(() => {
+    if (firstRender.current) {
+      firstRender.current = false;
+      return;
+    }
+    const changedDeps = getChangedDependencyIndexes(
+      prevDeps.current,
+      dependencies
+    );
+    if (changedDeps.length > 0) {
+      console.log("Changed dependencies:", changedDeps);
+    }
+    prevDeps.current = dependencies;
+  }, dependencies);
+};
+
+// src/common/IdGeneration/getSimpleId.ts
+var LAST_HAST_ID = 0;
+var textEncoder = new TextEncoder();
+var bytesToBinaryString = (bytes) => {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += String.fromCharCode(bytes[i]);
+  }
+  return out;
+};
+var getBase64EncodedString = (input) => {
+  const bytes = textEncoder.encode(input);
+  let base64 = "";
+  if (typeof globalThis.btoa === "function") {
+    const binary = bytesToBinaryString(bytes);
+    base64 = globalThis.btoa(binary);
+  } else {
+    const anyGlobal = globalThis;
+    if (typeof anyGlobal.Buffer === "function") {
+      base64 = anyGlobal.Buffer.from(bytes).toString("base64");
+    } else {
+      throw new Error("No base64 encoder available (need btoa or Buffer).");
+    }
+  }
+  return base64;
+};
+var getSimpleId = () => {
+  const hashId = LAST_HAST_ID++;
+  const base64Datetime = getBase64EncodedString(
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const rand1 = Math.random().toString(36).substring(2, 15);
+  const rand2 = Math.random().toString(36).substring(2, 15);
+  return `${hashId}-${base64Datetime}-${rand1}-${rand2}`;
+};
+
+// src/app/utils/TypeInfoORMAPIUtils.ts
+var handleRequest = async (requestId, args, typeInfoORMAPI, methodName, onRequestStateChange) => {
+  onRequestStateChange(methodName, requestId, { loading: true });
+  try {
+    const requestMethod = typeInfoORMAPI[methodName];
+    const result = await requestMethod(...args);
+    onRequestStateChange(methodName, requestId, {
+      loading: false,
+      data: result
+    });
+  } catch (error) {
+    onRequestStateChange(methodName, requestId, {
+      loading: false,
+      error: typeof error === "object" && error !== null && "message" in error ? error.message : void 0
+    });
+  }
+};
+var requestHandlerFactory = (typeInfoORMAPI, methodName, onRequestStateChange) => (...args) => {
+  const requestId = getSimpleId();
+  handleRequest(
+    requestId,
+    args,
+    typeInfoORMAPI,
+    methodName,
+    onRequestStateChange
+  );
+  return requestId;
+};
+var useTypeInfoORMAPI = (typeInfoORMAPI) => {
+  const [state, setState] = useState({});
+  const onRequestStateChange = useCallback(
+    (methodName, requestId, { loading, data, error }) => {
+      setState(
+        ({
+          [methodName]: {
+            activeRequests: prevActiveRequests = [],
+            data: prevData,
+            error: prevError
+          } = {},
+          ...prevState
+        }) => {
+          const newActiveRequests = loading ? [...prevActiveRequests, requestId] : prevActiveRequests.filter((id) => id !== requestId);
+          const currentlyLoading = newActiveRequests.length > 0;
+          return {
+            ...prevState,
+            [methodName]: {
+              activeRequests: newActiveRequests,
+              loading: currentlyLoading,
+              data: currentlyLoading ? void 0 : data ?? prevData,
+              error: currentlyLoading ? void 0 : error ?? prevError
+            }
+          };
+        }
+      );
+    },
+    []
+  );
+  const api = useMemo(() => {
+    const apiBase = {};
+    for (const aM in typeInfoORMAPI) {
+      const methodName = aM;
+      apiBase[methodName] = requestHandlerFactory(
+        typeInfoORMAPI,
+        methodName,
+        onRequestStateChange
+      );
+    }
+    return apiBase;
+  }, [typeInfoORMAPI, onRequestStateChange]);
+  return {
+    state,
+    api
+  };
+};
+
+// src/app/utils/TypeInfoORMClient.ts
+var TypeInfoORMClient = class {
+  /**
+   * Create a client for TypeInfoORM routes.
+   *
+   * @param config - Service configuration for the API routes.
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Dispatch a request to the configured service.
+   *
+   * @param path - Route path for the ORM method.
+   * @param args - Arguments to send in the request body.
+   * @returns Parsed response payload.
+   */
+  makeRequest = async (path, args) => {
+    const cleanedArgs = [...args];
+    while (cleanedArgs.length > 0 && typeof cleanedArgs[cleanedArgs.length - 1] === "undefined") {
+      cleanedArgs.pop();
+    }
+    const result = await sendServiceRequest(this.config, path, cleanedArgs);
+    return result;
+  };
+  /**
+   * Create an item of the provided type.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param item - Item payload to persist.
+   * @returns The created item result.
+   */
+  create = async (typeName, item) => {
+    return await this.makeRequest("create" /* CREATE */, [
+      typeName,
+      item
+    ]);
+  };
+  /**
+   * Read an item by its primary field value.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param primaryFieldValue - Primary field value to lookup.
+   * @returns The retrieved item, if found.
+   */
+  read = async (typeName, primaryFieldValue, selectedFields) => {
+    return await this.makeRequest("read" /* READ */, [
+      typeName,
+      primaryFieldValue,
+      selectedFields
+    ]);
+  };
+  /**
+   * Update an item by replacing it with the provided payload.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param item - Updated item payload.
+   * @returns Whether the update succeeded.
+   */
+  update = async (typeName, item) => {
+    return await this.makeRequest("update" /* UPDATE */, [
+      typeName,
+      item
+    ]);
+  };
+  /**
+   * Delete an item by its primary field value.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param primaryFieldValue - Primary field value to delete.
+   * @returns Whether the delete succeeded.
+   */
+  delete = async (typeName, primaryFieldValue) => {
+    return await this.makeRequest("delete" /* DELETE */, [
+      typeName,
+      primaryFieldValue
+    ]);
+  };
+  /**
+   * List items for a given type.
+   *
+   * @param typeName - TypeInfo type name.
+   * @param config - List configuration including filters and paging.
+   * @param selectedFields - Optional fields to project.
+   * @returns List results for the query.
+   */
+  list = async (typeName, config, selectedFields) => {
+    return await this.makeRequest("list" /* LIST */, [
+      typeName,
+      config,
+      selectedFields
+    ]);
+  };
+  /**
+   * Create a relationship between items.
+   *
+   * @param relationshipItem - Relationship payload.
+   * @returns Whether the relationship was created.
+   */
+  createRelationship = async (relationshipItem) => {
+    return await this.makeRequest(
+      "create-relationship" /* CREATE_RELATIONSHIP */,
+      [relationshipItem]
+    );
+  };
+  /**
+   * Delete a relationship between items.
+   *
+   * @param relationshipItem - Relationship payload.
+   * @returns Results describing the deletion.
+   */
+  deleteRelationship = async (relationshipItem) => {
+    return await this.makeRequest(
+      "delete-relationship" /* DELETE_RELATIONSHIP */,
+      [relationshipItem]
+    );
+  };
+  /**
+   * List relationship records matching the query.
+   *
+   * @param config - Relationship list query configuration.
+   * @returns Relationship list results.
+   */
+  listRelationships = async (config) => {
+    return await this.makeRequest("list-relationships" /* LIST_RELATIONSHIPS */, [
+      config
+    ]);
+  };
+  /**
+   * List related items for a relationship query.
+   *
+   * @param config - Relationship list query configuration.
+   * @param selectedFields - Optional fields to project on related items.
+   * @returns Related item list results.
+   */
+  listRelatedItems = async (config, selectedFields) => {
+    return await this.makeRequest("list-related-items" /* LIST_RELATED_ITEMS */, [
+      config,
+      selectedFields
+    ]);
+  };
+};
+
+// src/app/forms/core/mergeSuites.ts
+var mergeSuites = (base, overrides) => {
+  return {
+    renderers: {
+      ...base.renderers ?? {},
+      ...overrides.renderers ?? {}
+    },
+    primitives: {
+      ...base.primitives ?? {},
+      ...overrides.primitives ?? {}
+    }
+  };
+};
+var withRendererOverride = (kind, renderer) => ({
+  renderers: {
+    [kind]: renderer
+  }
+});
+
+export { ApplicationStateContext, ApplicationStateProvider, TypeInfoORMClient, getApplicationStateIdentifier, getApplicationStateModified, getApplicationStateValue, getApplicationStateValueStructure, getChangedDependencyIndexes, getFullUrl, handleRequest, mergeSuites, requestHandlerFactory, sendServiceRequest, setApplicationStateModified, setApplicationStateValue, useApplicationStateLoader, useApplicationStateValue, useApplicationStateValueStructure, useController, useDebugDependencies, useTypeInfoORMAPI, withRendererOverride };