@croz/nrich-registry-core/dist/index.mjs

Contains core utilities related to the nrich-registry module

var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/component/RegistryEntityContext.tsx
import React, { useContext } from "react";

// src/store/registry-configuration-store.ts
import create from "zustand";
var useRegistryConfigurationStore = create((set) => ({
  groupConfigurations: [],
  load: (groupConfigurations) => set(() => ({
    groupConfigurations
  })),
  entityFormatters: {},
  setEntityFormatters: (entityFormatters) => set(() => ({
    entityFormatters
  })),
  registryConfiguration: {},
  setRegistryConfiguration: (registryConfiguration) => set(() => ({
    registryConfiguration
  }))
}));

// src/component/RegistryEntityContext.tsx
var RegistryEntityContext = React.createContext(void 0);
var useRegistryEntityContext = () => {
  const context = useContext(RegistryEntityContext);
  if (!context) {
    throw new Error("Cannot use RegistryEntityContext without RegistryEntityContextProvider!");
  }
  return context;
};
var RegistryEntityContextProvider = ({ entityConfiguration, children }) => {
  const entityConfigurations = useRegistryConfigurationStore((state) => state.groupConfigurations.flatMap((groupConfiguration) => groupConfiguration.entityConfigurationList));
  const singularAssociationsMap = React.useMemo(() => {
    const singularAssociations = [...entityConfiguration.propertyConfigurationList, ...entityConfiguration.embeddedIdPropertyConfigurationList].filter((property) => property.singularAssociation).map((property) => property.singularAssociationReferencedClass);
    return singularAssociations.reduce(
      (all, current) => __spreadProps(__spreadValues({}, all), { [current]: entityConfigurations.find((configuration) => configuration.classFullName === current) }),
      {}
    );
  }, [entityConfiguration]);
  const finalProperties = React.useMemo(() => {
    if (entityConfiguration.embeddedIdentity) {
      return entityConfiguration.propertyConfigurationList.flatMap((property) => {
        if (property.id) {
          return entityConfiguration.embeddedIdPropertyConfigurationList;
        }
        return property;
      });
    }
    return entityConfiguration.propertyConfigurationList;
  }, [entityConfiguration]);
  const value = React.useMemo(() => ({
    entityConfiguration,
    finalProperties,
    singularAssociationsMap
  }), [entityConfiguration]);
  return /* @__PURE__ */ React.createElement(RegistryEntityContext.Provider, {
    value
  }, children);
};

// src/component/RegistryProvider.tsx
import React2 from "react";

// src/service/service.ts
var loadRegistryConfiguration = () => __async(void 0, null, function* () {
  var _a;
  const { registryConfiguration } = useRegistryConfigurationStore.getState();
  const additionalOptions = ((_a = registryConfiguration.requestOptionsResolver) == null ? void 0 : _a.call(registryConfiguration)) || {};
  const finalBaseUrl = registryConfiguration.baseURL || "/nrich/registry";
  const response = yield fetch(`${finalBaseUrl}/configuration/fetch`, __spreadValues({
    method: "POST"
  }, additionalOptions));
  const data = yield response.json();
  return data;
});
var loadEntities = (request) => __async(void 0, null, function* () {
  var _a;
  const { registryConfiguration } = useRegistryConfigurationStore.getState();
  const additionalOptions = ((_a = registryConfiguration.requestOptionsResolver) == null ? void 0 : _a.call(registryConfiguration)) || {};
  const finalBaseUrl = registryConfiguration.baseURL || "/nrich/registry";
  const response = yield fetch(`${finalBaseUrl}/data/list`, __spreadValues({
    method: "POST",
    body: JSON.stringify(request),
    headers: { "Content-Type": "application/json" }
  }, additionalOptions));
  const data = yield response.json();
  return data;
});
var bulkLoadEntities = (requests) => __async(void 0, null, function* () {
  var _a;
  const { registryConfiguration } = useRegistryConfigurationStore.getState();
  const additionalOptions = ((_a = registryConfiguration.requestOptionsResolver) == null ? void 0 : _a.call(registryConfiguration)) || {};
  const finalBaseUrl = registryConfiguration.baseURL || "/nrich/registry";
  const response = yield fetch(`${finalBaseUrl}/data/list-bulk`, __spreadValues({
    method: "POST",
    body: JSON.stringify({
      registryRequestList: requests
    }),
    headers: { "Content-Type": "application/json" }
  }, additionalOptions));
  const data = yield response.json();
  return data;
});
var createEntity = (classFullName, createData) => __async(void 0, null, function* () {
  var _a;
  const { registryConfiguration } = useRegistryConfigurationStore.getState();
  const additionalOptions = ((_a = registryConfiguration.requestOptionsResolver) == null ? void 0 : _a.call(registryConfiguration)) || {};
  const finalBaseUrl = registryConfiguration.baseURL || "/nrich/registry";
  const response = yield fetch(`${finalBaseUrl}/data/create`, __spreadValues({
    method: "POST",
    body: JSON.stringify({
      classFullName,
      jsonEntityData: JSON.stringify(createData)
    }),
    headers: { "Content-Type": "application/json" }
  }, additionalOptions));
  const data = yield response.json();
  return data;
});
var updateEntity = (classFullName, id, updateData) => __async(void 0, null, function* () {
  var _a;
  const { registryConfiguration } = useRegistryConfigurationStore.getState();
  const additionalOptions = ((_a = registryConfiguration.requestOptionsResolver) == null ? void 0 : _a.call(registryConfiguration)) || {};
  const finalBaseUrl = registryConfiguration.baseURL || "/nrich/registry";
  const response = yield fetch(`${finalBaseUrl}/data/update`, __spreadValues({
    method: "POST",
    body: JSON.stringify({
      classFullName,
      id,
      jsonEntityData: JSON.stringify(updateData)
    }),
    headers: { "Content-Type": "application/json" }
  }, additionalOptions));
  const data = yield response.json();
  return data;
});
var removeEntity = (classFullName, id) => __async(void 0, null, function* () {
  var _a;
  const { registryConfiguration } = useRegistryConfigurationStore.getState();
  const additionalOptions = ((_a = registryConfiguration.requestOptionsResolver) == null ? void 0 : _a.call(registryConfiguration)) || {};
  const finalBaseUrl = registryConfiguration.baseURL || "/nrich/registry";
  const response = yield fetch(`${finalBaseUrl}/data/delete`, __spreadValues({
    method: "POST",
    body: JSON.stringify({ classFullName, id }),
    headers: { "Content-Type": "application/json" }
  }, additionalOptions));
  return response;
});

// src/component/RegistryProvider.tsx
var RegistryProvider = ({ children, registryConfiguration = {}, entityFormatters = {} }) => {
  const { load, setRegistryConfiguration, setEntityFormatters } = useRegistryConfigurationStore();
  const [loading, setLoading] = React2.useState(true);
  React2.useEffect(() => {
    const loadConfiguration = () => __async(void 0, null, function* () {
      setRegistryConfiguration(__spreadValues({}, registryConfiguration));
      setEntityFormatters(entityFormatters);
      const configuration = yield loadRegistryConfiguration();
      load(configuration);
      setLoading(false);
    });
    loadConfiguration();
  }, []);
  if (loading) {
    return /* @__PURE__ */ React2.createElement("div", null, "Loading...");
  }
  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
};

// src/hook/use-registry-entity.ts
import React3 from "react";

// src/hook/use-entity-configuration.ts
var useEntityConfiguration = (name) => {
  const entityConfiguration = useRegistryConfigurationStore((state) => state.groupConfigurations.flatMap((groupConfiguration) => groupConfiguration.entityConfigurationList).find((configuration) => configuration.name === name || configuration.classFullName === name));
  if (entityConfiguration === void 0) {
    return void 0;
  }
  const entityIdProperty = entityConfiguration.propertyConfigurationList.find((property) => property.id);
  return { entityConfiguration, entityIdProperty };
};

// src/hook/use-registry-entity.ts
var INITIAL_PAGE_SIZE = 25;
var DEFAULT_INITIAL_REQUEST = {
  pageNumber: 0,
  pageSize: INITIAL_PAGE_SIZE
};
var useRegistryEntity = (name, initialRequest = DEFAULT_INITIAL_REQUEST) => {
  const { entityConfiguration, entityIdProperty } = useEntityConfiguration(name);
  const [data, setData] = React3.useState({
    content: [],
    empty: true,
    first: true,
    last: true,
    sort: {
      sorted: false,
      unsorted: true
    },
    numberOfElements: 0,
    totalElements: 0,
    totalPages: 0
  });
  const load = (request) => __async(void 0, null, function* () {
    const loadedData = yield loadEntities(__spreadValues({ classFullName: entityConfiguration.classFullName }, request));
    setData(loadedData);
  });
  React3.useEffect(() => {
    load(initialRequest);
  }, []);
  const add = (createData) => __async(void 0, null, function* () {
    const response = yield createEntity(entityConfiguration.classFullName, createData);
    yield load(initialRequest);
    return response;
  });
  const edit = (id, updateData) => __async(void 0, null, function* () {
    const response = yield updateEntity(entityConfiguration.classFullName, id, updateData);
    yield load(initialRequest);
    return response;
  });
  const remove = (id) => __async(void 0, null, function* () {
    const response = yield removeEntity(entityConfiguration.classFullName, id);
    yield load(initialRequest);
    return response;
  });
  return {
    entityConfiguration,
    entityIdProperty,
    data,
    load,
    add,
    edit,
    remove
  };
};

// src/hook/use-registry-entity-administration.ts
import React5 from "react";

// src/util/registry-entity-utils.ts
var resolveId = (entityConfiguration, data) => {
  if (entityConfiguration.idClassIdentity) {
    const id = {};
    entityConfiguration.idClassPropertyNameList.forEach((property) => {
      id[property.name] = data[property.name];
    });
    return id;
  }
  const idField = entityConfiguration.propertyConfigurationList.find((property) => property.id === true);
  return data[idField.name];
};
var resolveValue = (propertyConfiguration, data) => {
  const fieldPath = propertyConfiguration.name;
  if (fieldPath.includes(".")) {
    let current = data;
    fieldPath.split(".").forEach((fieldPathPart) => {
      current = current[fieldPathPart];
    });
    return current;
  }
  return data[fieldPath];
};
var restructureSubmitValue = (value) => {
  const result = {};
  Object.keys(value).forEach((key) => {
    if (key.includes(".")) {
      let current = result;
      key.split(".").forEach((fieldPathPart, i, arr) => {
        var _a;
        if (i === arr.length - 1) {
          current[fieldPathPart] = value[key];
        } else {
          current[fieldPathPart] = __spreadValues({}, (_a = current[fieldPathPart]) != null ? _a : {});
          current = current[fieldPathPart];
        }
      });
    } else {
      result[key] = value[key];
    }
  });
  return result;
};
var formatIdName = (classFullName, idFieldName, id) => `${classFullName.split(".").pop()}[${idFieldName}=${id}]`;
var findIdField = (entityConfiguration) => entityConfiguration.propertyConfigurationList.find((property) => property.id);

// src/hook/use-update-effect.ts
import React4 from "react";
var useUpdateEffect = (effect, dependencies) => {
  const firstRender = React4.useRef(true);
  React4.useEffect(() => {
    firstRender.current = true;
  }, []);
  React4.useEffect(() => {
    if (!firstRender.current) {
      return effect();
    }
    firstRender.current = false;
    return void 0;
  }, dependencies);
};
var useDebouncedUpdateEffect = (effect, debounceTime, dependencies) => {
  const firstRender = React4.useRef(true);
  const timeoutRef = React4.useRef(null);
  const clearTimeout = () => window.clearTimeout(timeoutRef.current);
  React4.useEffect(() => {
    firstRender.current = true;
    clearTimeout();
  }, []);
  React4.useEffect(() => {
    clearTimeout();
    if (!firstRender.current) {
      timeoutRef.current = setTimeout(() => {
        effect();
      }, debounceTime);
    }
    firstRender.current = false;
  }, dependencies);
};

// src/hook/use-registry-entity-administration.ts
var useRegistryEntityAdministration = (entityName) => {
  const [request, setRequest] = React5.useState(DEFAULT_INITIAL_REQUEST);
  const registryEntity = useRegistryEntity(entityName, request);
  const [formModalOpen, setFormModalOpen] = React5.useState(false);
  const [formType, setFormType] = React5.useState(void 0);
  const [formData, setFormData] = React5.useState();
  const [loading, setLoading] = React5.useState(false);
  const {
    entityConfiguration,
    entityIdProperty,
    data,
    add,
    edit,
    remove
  } = registryEntity;
  const handlePagingUpdate = (newPagingRequest) => __async(void 0, null, function* () {
    setRequest((oldRequest) => __spreadValues(__spreadValues({}, oldRequest), newPagingRequest));
  });
  const handleFilterUpdate = (searchParameter) => __async(void 0, null, function* () {
    setRequest((oldRequest) => __spreadProps(__spreadValues({}, oldRequest), { pageNumber: 0, searchParameter }));
  });
  useUpdateEffect(() => {
    const reload = () => __async(void 0, null, function* () {
      setLoading(true);
      yield registryEntity.load(request);
      setLoading(false);
    });
    reload();
  }, [request]);
  const handleAddClick = () => {
    setFormModalOpen(true);
    setFormType("create");
    setFormData(void 0);
  };
  const handleAddFromCopyClick = (row) => {
    setFormModalOpen(true);
    setFormType("create");
    setFormData(row);
  };
  const handleEditClick = (id, row) => {
    setFormModalOpen(true);
    setFormType("update");
    setFormData(row);
  };
  const handlePreviewClick = (row) => {
    setFormModalOpen(true);
    setFormType("preview");
    setFormData(row);
  };
  const handleSubmitClick = (values) => __async(void 0, null, function* () {
    const finalValue = restructureSubmitValue(values);
    let actionResponse;
    setFormModalOpen(false);
    setLoading(true);
    if (formType === "update") {
      actionResponse = yield edit(formData[entityIdProperty.name], finalValue);
    } else {
      actionResponse = yield add(finalValue);
    }
    setLoading(false);
    setFormType(void 0);
    setFormData(void 0);
    return actionResponse;
  });
  const closeFormModal = () => {
    setFormModalOpen(false);
    setFormType(void 0);
    setFormData(void 0);
  };
  return {
    entityConfiguration,
    entityIdProperty,
    data,
    request,
    handlePagingUpdate,
    handleFilterUpdate,
    handleAddClick,
    handleAddFromCopyClick,
    handleEditClick,
    handlePreviewClick,
    handleSubmitClick,
    formType,
    formData,
    formModalOpen,
    closeFormModal,
    loading,
    remove
  };
};

// src/hook/use-registry-entity-form-configuration.ts
import { useYupFormConfiguration } from "@croz/nrich-form-configuration-core";
var useRegistryEntityYupFormConfiguration = (classFullName, type) => useYupFormConfiguration(`${classFullName}:::${type}`);

// src/hook/use-registry-filter.ts
import React6 from "react";
var INITIAL_FILTER_VALUE = { query: "", propertyNameList: [] };
var useRegistryFilter = (initialFilterValue = INITIAL_FILTER_VALUE) => {
  const { finalProperties } = React6.useContext(RegistryEntityContext);
  const [searchParameter, setSearchParameter] = React6.useState(initialFilterValue);
  const handleFieldsChange = (event) => {
    const { value } = event.target;
    const newValue = typeof value === "string" ? value.split(",") : value;
    setSearchParameter((oldSearchParameter) => __spreadProps(__spreadValues({}, oldSearchParameter), { propertyNameList: newValue }));
  };
  const handleQueryChange = (event) => {
    const { value } = event.target;
    setSearchParameter((oldSearchParameter) => __spreadProps(__spreadValues({}, oldSearchParameter), { query: value }));
  };
  const availableFields = React6.useMemo(
    () => finalProperties.filter((property) => property.searchable).map((property) => ({ value: property.name, label: property.columnHeader })),
    [finalProperties]
  );
  return {
    availableFields,
    searchParameter,
    handleFieldsChange,
    handleQueryChange
  };
};

// src/hook/use-registry-form.ts
import React7 from "react";
var useRegistryForm = (initialValues, type) => {
  const { entityConfiguration, finalProperties } = React7.useContext(RegistryEntityContext);
  const yupSchema = useRegistryEntityYupFormConfiguration(entityConfiguration.classFullName, type);
  const finalInitialValues = React7.useMemo(() => {
    if (initialValues === void 0) {
      const values2 = {};
      finalProperties.forEach((property) => {
        values2[property.name] = null;
      });
      return values2;
    }
    const values = {};
    finalProperties.forEach((property) => {
      values[property.name] = resolveValue(property, initialValues);
    });
    return values;
  }, [initialValues]);
  const properties = type === "update" ? finalProperties : finalProperties.filter((property) => property.editable);
  return {
    entityConfiguration,
    yupSchema,
    finalInitialValues,
    properties
  };
};

// src/hook/use-registry-sort.ts
import React8 from "react";
var useRegistrySort = (propertyConfiguration, value, onChange, allowMultiple = true) => {
  const sortDirection = React8.useMemo(() => {
    const sortProperty = value.find((pagingRequestSortProperty) => pagingRequestSortProperty.property === propertyConfiguration.name);
    if (sortProperty === void 0) {
      return void 0;
    }
    return sortProperty.direction;
  }, [propertyConfiguration, value]);
  const sortChangeHandler = () => {
    const sortProperty = value.find((pagingRequestSortProperty) => pagingRequestSortProperty.property === propertyConfiguration.name);
    if (sortProperty === void 0) {
      onChange([
        ...allowMultiple ? value : [],
        { property: propertyConfiguration.name, direction: "ASC" }
      ]);
    } else if (sortProperty.direction === "ASC") {
      onChange(value.map((pagingRequestSortProperty) => {
        if (pagingRequestSortProperty.property === propertyConfiguration.name) {
          return __spreadProps(__spreadValues({}, pagingRequestSortProperty), { direction: "DESC" });
        }
        return pagingRequestSortProperty;
      }));
    } else {
      onChange(value.filter((pagingRequestSortProperty) => pagingRequestSortProperty.property !== propertyConfiguration.name));
    }
  };
  return {
    sortDirection,
    sortChangeHandler
  };
};
export {
  DEFAULT_INITIAL_REQUEST,
  RegistryEntityContext,
  RegistryEntityContextProvider,
  RegistryProvider,
  bulkLoadEntities,
  createEntity,
  findIdField,
  formatIdName,
  loadEntities,
  loadRegistryConfiguration,
  removeEntity,
  resolveId,
  resolveValue,
  restructureSubmitValue,
  updateEntity,
  useDebouncedUpdateEffect,
  useRegistryConfigurationStore,
  useRegistryEntity,
  useRegistryEntityAdministration,
  useRegistryEntityContext,
  useRegistryEntityYupFormConfiguration,
  useRegistryFilter,
  useRegistryForm,
  useRegistrySort,
  useUpdateEffect
};
//# sourceMappingURL=index.mjs.map