@arpproject/recrate 0.1.7 → 0.1.8

package/src/crate-builder/CrateManager/profile-manager.ts

@@ -1,367 +0,0 @@
-import schemaOrgTypeDefinitions from "./schema-type-definitions.json";
-import isArray from "lodash/isArray";
-import isEmpty from "lodash/isEmpty";
-import flattenDeep from "lodash/flattenDeep";
-import cloneDeep from "lodash/cloneDeep";
-import orderBy from "lodash/orderBy";
-import has from "lodash/has";
-import compact from "lodash/compact";
-import uniq from "lodash/uniq";
-import uniqBy from "lodash/uniqBy";
-import intersection from "lodash/intersection";
-import type {
-    NormalisedProfile,
-    NormalisedEntityDefinition,
-    ProfileLayout,
-    ProfileInput,
-    EntityReference,
-} from "../types";
-
-/**
- * @class
- *
- * ProfileManager
- *
- * A class to work with Describo Profiles
- *
- * @param {profile} - profile to handle
- */
-export class ProfileManager {
-    profile?: NormalisedProfile;
-    $key?: number;
-    context?: any;
-    
-    constructor({ profile }: { profile?: NormalisedProfile }) {
-        if (profile) {
-            this.profile = profile;
-            this.__processInputs();
-        }
-    }
-
-    /**
-     * Process input definitions for certain types.
-     *
-     * For now it takes care of setting 'handlesMultipleValues' for input types, which can have multiple values
-     * but handle all values themselves and not require a new render property added for each new value. This is the
-     * case for checbox style selects. It provides the same functionality as a normal select but all values are
-     * visible and selectable at once and not one by one.
-     *
-     * It also makes sure that for radio style selects "multiple" is always set to "false", as radio input only
-     * provides a single value selected form many.
-     *
-     * @private
-     */
-    private __processInputs() {
-        if (!this.profile?.classes) return;
-
-        for (const className in this.profile.classes) {
-            const classDefinition = this.profile.classes[className];
-            if (!classDefinition.inputs) continue;
-
-            classDefinition.inputs = classDefinition.inputs.map(input => {
-                if (input.type.includes("Select") && input.style === "checkbox") {
-                    return {
-                        ...input,
-                        multiple: false, // must set explicitly, otherwise will be set to true implicitly later
-                        handlesMultipleValues: true
-                    };
-                } else if (input.type.includes("Select") && input.style === "radio") {
-                    return {
-                        ...input,
-                        multiple: false, // on case of radio, it must always be false
-                    };
-                }
-
-                return input;
-            });
-        }
-    }
-
-    /**
-     *
-     * Get the layout for an entity from the profile
-     *
-     * Returns the first matching layout from the profile
-     *
-     * @param { Object } options
-     * @param { Object } options.entity - the entity whose layout is required
-     *
-     */
-    getLayout({
-        entity,
-    }: {
-        entity: NormalisedEntityDefinition | EntityReference;
-    }): ProfileLayout | null {
-        // no layout defined in profile
-        if (!this.profile?.layouts || !this.profile.layouts.length) return null;
-        let layouts = this.profile.layouts;
-        let layout = layouts.filter((layout) => {
-            return intersection(layout.appliesTo, (entity as any)["@type"]).length;
-        });
-
-        // no matching layout found
-        if (!layout.length) return null;
-
-        // match found - make sure it has about and overflow placeholders
-        let firstMatchingLayout = layout[0];
-        if (!firstMatchingLayout.about) {
-            firstMatchingLayout.about = {
-                name: "about",
-                label: "About",
-                inputs: [],
-                order: 0,
-            };
-        }
-        if (!firstMatchingLayout.overflow) {
-            firstMatchingLayout.overflow = {
-                name: "overflow",
-                label: "...",
-                inputs: [],
-                order: Object.keys(layout).length,
-            };
-        }
-
-        // return it
-        return firstMatchingLayout;
-    }
-
-    /**
-     * Get inverse associations from the profile if any are defined
-     */
-    getPropertyAssociations(): { [key: string]: { property: string; propertyId: string } } {
-        if (!this.profile?.propertyAssociations) return {};
-
-        // create the associations both ways and return
-        const associations: { [key: string]: { property: string; propertyId: string } } = {};
-        this.profile.propertyAssociations.forEach((a) => {
-            associations[a.property] = a.inverse;
-            associations[a.inverse.property] = { property: a.property, propertyId: a.propertyId };
-        });
-        return associations;
-    }
-
-    /**
-     *
-     * Get the available classes
-     *   if a profile is defined, get those
-     *
-     * Returns the classes defined in the profile if one is applied
-     *   or all of the classes built into the base, schema.org profile
-     *
-     */
-    getClasses() {
-        if (this.profile?.classes) {
-            return Object.keys(this.profile?.classes).sort();
-        } else {
-            return Object.keys(schemaOrgTypeDefinitions).sort();
-        }
-    }
-
-    /**
-     *
-     * Return the type hierarchy for the given entity
-     *
-     * @param { Object } options
-     * @param { Object } options.entity - the entity whose hierarchy is required
-     *
-     *
-     */
-    getEntityTypeHierarchy({ entity }: { entity: NormalisedEntityDefinition }) {
-        let types = entity["@type"];
-        types = this.mapTypeHierarchies({ types });
-        return types;
-    }
-
-    /**
-     *
-     * Given an entity, try to find a definition for the property in the profile or
-     *  right across the hierarchy
-     *
-     * @param { Object } options
-     * @param { Object } options.property - the property to define
-     * @param { Object } options.entity - the entity this property is a part of
-     *
-     */
-    getPropertyDefinition({
-        property,
-        entity,
-    }: {
-        property: string;
-        entity: NormalisedEntityDefinition;
-    }) {
-        let propertyDefinition = {} as ProfileInput;
-        let inputs = this.getInputsFromProfile({ entity });
-        if (inputs.length) {
-            // we found an entity definition in the profile - do we have a property definition?
-            let definition = inputs.filter((p) => p.name.toLowerCase() === property.toLowerCase());
-            if (definition.length) {
-                // console.debug(
-                //     "PROFILE property definition:",
-                //     JSON.stringify(propertyDefinition, null, 2)
-                // );
-                propertyDefinition = cloneDeep(definition[0]);
-            }
-        }
-        // unable to locate a property definition in the profile - look in schema.org
-        if (isEmpty(propertyDefinition)) {
-            let { inputs } = this.getAllInputs({ entity });
-            let definition = inputs.filter((p) => p.name.toLowerCase() === property.toLowerCase());
-            if (definition.length) {
-                // console.debug(
-                //     "SCHEMA ORG property definition:",
-                //     JSON.stringify(propertyDefinition, null, 2)
-                // );
-                propertyDefinition = cloneDeep(definition[0]);
-            }
-        }
-
-        // unable to locate a property definition in schema.org - create a default one
-        if (isEmpty(propertyDefinition)) {
-            // console.debug(
-            //     "DEFAULT property definition:",
-            //     JSON.stringify(propertyDefinition, null, 2)
-            // );
-            propertyDefinition = {
-                id: "",
-                name: "",
-                type: ["Text"],
-                help: "",
-                multiple: true,
-            };
-        }
-
-        if (!isArray(propertyDefinition.type)) {
-            propertyDefinition.type = [propertyDefinition.type];
-        }
-        if (!has(propertyDefinition, "multiple")) propertyDefinition.multiple = true;
-
-        return { propertyDefinition };
-    }
-
-    /**
-     *
-     * Given a set of types, figure out the type hierarchy taking into account
-     *  the parent types that this is a subClassOf
-     */
-    mapTypeHierarchies({ types }: { types: string[] }) {
-        types = cloneDeep(types);
-        if (!types.includes("Thing")) types.push("Thing");
-
-        types = flattenDeep(
-            types.map((type) => [type, this.profile?.classes?.[type]?.subClassOf ?? []])
-        );
-        types = compact(types);
-
-        types = flattenDeep(
-            types.map((type) => {
-                return [
-                    type,
-                    (schemaOrgTypeDefinitions as { [key: string]: { hierarchy: string[] } })[type]
-                        ?.hierarchy ?? ["Thing"],
-                ];
-            })
-        );
-        types = uniq(types);
-        return types;
-    }
-
-    /**
-     *
-     * Given an entity, get the inputs defined in the profile
-     *
-     * @param { Object } options
-     * @param { Object } options.entity - the entity
-     *
-     */
-    getInputsFromProfile({ entity }: { entity: NormalisedEntityDefinition }): ProfileInput[] {
-        let types = entity["@type"];
-
-        let inputs: ProfileInput[] = [];
-        for (let type of types) {
-            if (this.profile?.classes?.[type]) {
-                //   yes - get it
-                inputs = [...inputs, ...cloneDeep(this.profile?.classes?.[type].inputs)];
-            }
-
-            // if the definition is set to inherit, and this class is a subclass of others,
-            //   go and get those inputs as well
-            if (
-                this.profile?.classes?.[type]?.definition === "inherit" &&
-                this.profile?.classes?.[type]?.subClassOf
-            ) {
-                for (let parentClass of this.profile?.classes?.[type]?.subClassOf) {
-                    inputs = [
-                        ...inputs,
-                        ...cloneDeep(this.profile?.classes?.[parentClass]?.inputs ?? []),
-                    ];
-                }
-            }
-        }
-        return uniqBy(inputs, "id");
-    }
-
-    /**
-     *
-     * Given an entity, get all available inputs by joining the profile with schema.org
-     *
-     * @param { Object } options
-     * @param { Object } options.entity - the entity
-     */
-    getAllInputs({ entity }: { entity: NormalisedEntityDefinition }): { inputs: ProfileInput[] } {
-        // let getInputsFunction = getInputs.bind(this);
-        const hierarchy = this.getEntityTypeHierarchy({ entity });
-        let inputs = [];
-
-        const getInputs = (type: string) => {
-            let inputs = [];
-            if (this.profile?.classes?.[type]) {
-                // type defined in profile - get those inputs
-                inputs.push(this.profile.classes[type].inputs);
-            }
-            if (this.profile?.classes?.[type]?.definition === "inherit") {
-                // profile type definition set to inherit - collect schema.org inputs
-                inputs.push((schemaOrgTypeDefinitions as any)[type].inputs);
-            }
-            if (!this.profile?.classes?.[type]) {
-                // no definition in profile - collect schema.org inputs
-                inputs.push((schemaOrgTypeDefinitions as any)?.[type]?.inputs);
-            }
-            return inputs;
-        };
-
-        for (let type of hierarchy) {
-            inputs.push(getInputs(type));
-        }
-        inputs = flattenDeep(inputs);
-        inputs = compact(inputs);
-        inputs = uniqBy(inputs, "id");
-        inputs = orderBy(inputs, "name");
-        return { inputs };
-    }
-
-    /**
-     *
-     * Try to get a definition from the profile and see if it's override or inherit
-     *
-     * If there's an override then return override - otherwise inherit. Exclusive rather than inclusive.
-     *
-     * @param { Object } options
-     * @param { Object } options.entity - the entity
-     * if there's an override then set to override - otherwise inherit
-     * be exclusive rather than inclusive
-     */
-    getTypeDefinition({ entity }: { entity: NormalisedEntityDefinition }) {
-        let types = entity["@type"];
-        let directive = types.map((type) => this.profile?.classes?.[type]?.definition);
-        return directive.includes("override") ? "override" : "inherit";
-    }
-
-    /**
-     * Get an entity label if defined
-     *
-     * @property the type name to localise
-     */
-    getTypeLabel(type: string) {
-        return this.profile?.localisation?.[type] ?? type;
-    }
-}