@arpproject/recrate 0.1.7-test3 → 0.1.7-test6

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;
-    }
-}

package/src/crate-builder/CrateManager/validate-identifier.spec.ts

@@ -1,82 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { validateId } from "./validate-identifier";
-
-describe("Test @id's that should be valid", () => {
-    test(`LICENCE.md should be valid`, () => {
-        expect(validateId({ id: "LICENCE.md", type: "File" }).isValid).toBeTruthy;
-        expect(validateId({ id: "LICENCE.md", type: "File, Licence" }).isValid).toBeTruthy;
-        expect(validateId({ id: "LICENCE.md", type: ["File", "Licence"] }).isValid).toBeTruthy;
-    });
-    test(`/path/to/file should be valid`, () => {
-        expect(validateId({ id: "/path/to/file", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`./ should be valid`, () => {
-        expect(validateId({ id: "./", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`../ should be valid`, () => {
-        expect(validateId({ id: "../", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`_:xxx should be valid`, () => {
-        expect(validateId({ id: "_:xxx", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`#xxx should be valid`, () => {
-        expect(validateId({ id: "#xxx", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`http://schema.org/name should be valid`, () => {
-        expect(validateId({ id: "http://schema.org/name", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`https://schema.org/name should be valid`, () => {
-        expect(validateId({ id: "https://schema.org/name", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`ftp://schema.org/name should be valid`, () => {
-        expect(validateId({ id: "ftp://schema.org/name", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`ftps://schema.org/name should be valid`, () => {
-        expect(validateId({ id: "ftps://schema.org/name", type: "Dataset" }).isValid).toBeTruthy;
-    });
-    test(`arcp://uuid,32a423d6-52ab-47e3-a9cd-54f418a48571/doc.html`, () => {
-        expect(
-            validateId({
-                id: "arcp://uuid,32a423d6-52ab-47e3-a9cd-54f418a48571/doc.html",
-                type: "Dataset",
-            }).isValid
-        ).toBeTruthy;
-    });
-    test(`arcp://uuid,b7749d0b-0e47-5fc4-999d-f154abe68065/pics/`, () => {
-        expect(
-            validateId({
-                id: "arcp://uuid,b7749d0b-0e47-5fc4-999d-f154abe68065/pics/",
-                type: "Dataset",
-            }).isValid
-        ).toBeTruthy;
-    });
-    test(`arcp://ni,sha-256;F-34D4TUeOfG0selz7REKRDo4XePkewPeQYtjL3vQs0/`, () => {
-        expect(
-            validateId({
-                id: "arcp://ni,sha-256;F-34D4TUeOfG0selz7REKRDo4XePkewPeQYtjL3vQs0/",
-                type: "Dataset",
-            }).isValid
-        ).toBeTruthy;
-    });
-    test(`arcp://name,gallery.example.org/`, () => {
-        expect(validateId({ id: "arcp://name,gallery.example.org/a", type: "Dataset" }).isValid)
-            .toBeTruthy;
-    });
-});
-describe("Test @id's that should NOT be valid", () => {
-    test(`no id passed`, () => {
-        expect(validateId({ id: "", type: "Dataset" })).toEqual({ isValid: false, message: "No identifier was provided." });
-    });
-    test(`aaa should not be valid`, () => {
-        expect(validateId({ id: "aaa", type: "Person" }).message).toEqual(
-            "The identifier is not valid according to the RO Crate spec nor is it a valid IRI."
-        );
-    });
-    test(`32a423d6-52ab-47e3-a9cd-54f418a48571 should not be valid`, () => {
-        expect(
-            validateId({ id: "32a423d6-52ab-47e3-a9cd-54f418a48571", type: "Person" }).message
-        ).toEqual(
-            `The identifier is not valid according to the RO Crate spec nor is it a valid IRI.`
-        );
-    });
-});

package/src/crate-builder/CrateManager/validate-identifier.ts

@@ -1,65 +0,0 @@
-import { validateIri, IriValidationStrategy } from "../lib/validate-iri";
-
-type ValidateIdParams = {
-    id: string | undefined;
-    type: string | string[];
-};
-
-type ValidateIdResponse = { isValid: boolean; message?: string };
-
-export function validateId({ id, type }: ValidateIdParams): ValidateIdResponse {
-    if (!id) {
-        return { isValid: false, message: "No identifier was provided." };
-    }
-
-    // if it's the root descriptor - it's valid
-    if (id === "ro-crate-metadata.json") {
-        return { isValid: true };
-    }
-
-    if (type) {
-        // if type matches File or Dataset then whatever is provided is valid
-        type = Array.isArray(type) ? type.join(", ") : type;
-        if (type.match(/file/i)) return { isValid: true };
-        if (type.match(/Dataset/i)) return { isValid: true };
-    }
-
-    // @id is relative
-    if (id.match(/^\/.*/)) return { isValid: true };
-
-    // @id starting with . is valid
-    if (id.match(/^\..*/)) return { isValid: true };
-
-    // @id starting with # is valid
-    if (id.match(/^\#.*/)) return { isValid: true };
-
-    // @id with blank node is valid
-    if (id.match(/^\_:.*/)) return { isValid: true };
-
-    // arcp URI's are valid
-    if (id.match(/arcp:\/\/name,.*/)) return { isValid: true };
-    if (id.match(/arcp:\/\/uuid,.*/)) return { isValid: true };
-    if (id.match(/arcp:\/\/ni,sha-256;,.*/)) return { isValid: true };
-    // return { isValid: true };
-
-    // otherwise check that the id is a valid IRI
-    try {
-        let result = validateIri(id, IriValidationStrategy.Strict);
-        if (!result) {
-            // it's valid
-            return { isValid: true };
-        }
-    } catch (error) {
-        return {
-            isValid: false,
-            message:
-                "The identifier is not valid according to the RO Crate spec nor is it a valid IRI.",
-        };
-    }
-
-    return {
-        isValid: false,
-        message:
-            "The identifier is not valid according to the RO Crate spec nor is it a valid IRI.",
-    };
-}