@researchdatabox/sails-ng-common 0.2.1 → 5.0.0-RC1

package/dist/src/config/form-override.outline.d.ts

@@ -0,0 +1,15 @@
+import { FormModesConfig } from "./shared.outline";
+import { AllFormComponentDefinitionOutlines } from "./dictionary.outline";
+import { VisitorComponentClassNamesType } from "./dictionary.model";
+import { FormOverrideModesClassConfig } from "./form-component.outline";
+/**
+ * The type that specifies the known transformations.
+ */
+export type KnownTransformsType = Partial<{
+    [key in VisitorComponentClassNamesType]: Partial<{
+        [key in VisitorComponentClassNamesType]: (source: any, formMode: FormModesConfig) => AllFormComponentDefinitionOutlines;
+    }>;
+}>;
+export type DefaultTransformsType = Partial<{
+    [key in VisitorComponentClassNamesType]: FormOverrideModesClassConfig;
+}>;

package/dist/src/config/form-override.outline.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1vdmVycmlkZS5vdXRsaW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbmZpZy9mb3JtLW92ZXJyaWRlLm91dGxpbmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/src/config/form-prehydrate.outline.d.ts

@@ -0,0 +1,17 @@
+import { CheckboxTreeNode } from './component/checkbox-tree.outline';
+export declare const FormPrehydrateRootKey: "__root__";
+export interface VocabTreeChildrenResponse {
+    data: CheckboxTreeNode[];
+    meta: {
+        vocabularyId: string;
+        parentId: string | null;
+        total: number;
+    };
+}
+export interface FormPrehydrateVocabTreePayload {
+    childrenByParentId: Record<string, VocabTreeChildrenResponse>;
+    selectedNotations: string[];
+}
+export interface FormPrehydratePayload {
+    vocabTrees?: Record<string, FormPrehydrateVocabTreePayload>;
+}

package/dist/src/config/form-prehydrate.outline.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormPrehydrateRootKey = void 0;
+exports.FormPrehydrateRootKey = '__root__';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1wcmVoeWRyYXRlLm91dGxpbmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29uZmlnL2Zvcm0tcHJlaHlkcmF0ZS5vdXRsaW5lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVhLFFBQUEscUJBQXFCLEdBQUcsVUFBbUIsQ0FBQyJ9

package/dist/src/config/form-types.model.d.ts

@@ -0,0 +1,6 @@
+import { FormValidatorDefinition } from "../validation/form.model";
+/**
+ * Check if the item is a valid form validation definition.
+ * @param item The item to check.
+ */
+export declare function isTypeFormValidatorDefinition(item: unknown): item is FormValidatorDefinition;

package/dist/src/config/form-types.model.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeFormValidatorDefinition = isTypeFormValidatorDefinition;
+const helpers_1 = require("./helpers");
+/**
+ * Check if the item is a valid form validation definition.
+ * @param item The item to check.
+ */
+function isTypeFormValidatorDefinition(item) {
+    if (item === undefined || item === null) {
+        return false;
+    }
+    const i = item;
+    const hasExpectedPropClass = 'class' in i && (0, helpers_1.guessType)(i.class) === 'string';
+    const hasExpectedPropClassValue = i.class?.toString()?.trim().length > 0;
+    const hasExpectedPropMessage = 'message' in i && (0, helpers_1.guessType)(i.message) === 'string';
+    const hasExpectedPropMessageValue = i.message?.toString()?.trim().length > 0;
+    const hasExpectedPropCreate = 'create' in i || 'createAsync' in i;
+    return hasExpectedPropClass && hasExpectedPropClassValue
+        && hasExpectedPropMessage && hasExpectedPropMessageValue
+        && hasExpectedPropCreate;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS10eXBlcy5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZm9ybS10eXBlcy5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVFBLHNFQWlCQztBQXpCRCx1Q0FBb0M7QUFJcEM7OztHQUdHO0FBQ0gsU0FBZ0IsNkJBQTZCLENBQUMsSUFBYTtJQUN2RCxJQUFJLElBQUksS0FBSyxTQUFTLElBQUksSUFBSSxLQUFLLElBQUksRUFBRSxDQUFDO1FBQ3RDLE9BQU8sS0FBSyxDQUFDO0lBQ2pCLENBQUM7SUFDRCxNQUFNLENBQUMsR0FBRyxJQUErQixDQUFDO0lBRTFDLE1BQU0sb0JBQW9CLEdBQUcsT0FBTyxJQUFJLENBQUMsSUFBSSxJQUFBLG1CQUFTLEVBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxLQUFLLFFBQVEsQ0FBQztJQUM3RSxNQUFNLHlCQUF5QixHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsUUFBUSxFQUFFLEVBQUUsSUFBSSxFQUFFLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQztJQUV6RSxNQUFNLHNCQUFzQixHQUFHLFNBQVMsSUFBSSxDQUFDLElBQUksSUFBQSxtQkFBUyxFQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxRQUFRLENBQUM7SUFDbkYsTUFBTSwyQkFBMkIsR0FBRyxDQUFDLENBQUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUM7SUFFN0UsTUFBTSxxQkFBcUIsR0FBRyxRQUFRLElBQUksQ0FBQyxJQUFJLGFBQWEsSUFBSSxDQUFDLENBQUM7SUFFbEUsT0FBTyxvQkFBb0IsSUFBSSx5QkFBeUI7V0FDakQsc0JBQXNCLElBQUksMkJBQTJCO1dBQ3JELHFCQUFxQixDQUFDO0FBQ2pDLENBQUMifQ==

package/dist/src/config/form-types.outline.d.ts

@@ -0,0 +1,48 @@
+import { FormComponentDefinitionFrame } from "./form-component.outline";
+import { FormConfigFrame } from "./form-config.outline";
+import { FieldDefinitionFrame } from "./field.outline";
+import { ReusableFormComponentDefinitionFrame } from "./component/reusable.outline";
+import { AvailableFormComponentDefinitionFrames } from "./dictionary.outline";
+/**
+ * Check if the item is a field definition (it has at least 'class' and optional 'config' properties).
+ * @param item The item to check.
+ */
+export declare function isTypeFieldDefinition(item: unknown): item is FieldDefinitionFrame;
+/**
+ * Check if the item is a field definition of a particular type by comparing the class name
+ * (class name is the discriminator in the type union).
+ * @param item The item to check.
+ * @param name The class name to check.
+ */
+export declare function isTypeFieldDefinitionName<T extends FieldDefinitionFrame>(item: unknown, name: string): item is T;
+/**
+ * Check if the item is a form component definition (it has at least 'name' and 'component' properties).
+ * @param item The item to check.
+ */
+export declare function isTypeFormComponentDefinition(item: unknown): item is FormComponentDefinitionFrame;
+/**
+ * Check if the item is a form definition of a particular type by comparing the component class
+ * (component class name is the discriminator in the type union).
+ * @param item The item to check.
+ * @param name The class name to check.
+ */
+export declare function isTypeFormComponentDefinitionName<T extends FormComponentDefinitionFrame>(item: unknown, name: string): item is T;
+/**
+ * Check if the item has a componentDefinitions array property.
+ * @param item The item to check.
+ */
+export declare function isTypeWithComponentDefinitions<T extends {
+    componentDefinitions: unknown[];
+}>(item: unknown): item is T;
+/**
+ * Check if the item is a FormConfig (it has a name and componentDefinitions array property).
+ * @param item The item to check.
+ */
+export declare function isTypeFormConfig<T extends FormConfigFrame>(item: unknown): item is T;
+/**
+ * Check if a form component definition specifies to use a reusable form config.
+ * @param item The form component definition.
+ * @param reusableFormDefNames The names of the available reusable form definitions.
+ * @protected
+ */
+export declare function isTypeReusableComponent(item: AvailableFormComponentDefinitionFrames, reusableFormDefNames: string[]): item is ReusableFormComponentDefinitionFrame;

package/dist/src/config/form-types.outline.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeFieldDefinition = isTypeFieldDefinition;
+exports.isTypeFieldDefinitionName = isTypeFieldDefinitionName;
+exports.isTypeFormComponentDefinition = isTypeFormComponentDefinition;
+exports.isTypeFormComponentDefinitionName = isTypeFormComponentDefinitionName;
+exports.isTypeWithComponentDefinitions = isTypeWithComponentDefinitions;
+exports.isTypeFormConfig = isTypeFormConfig;
+exports.isTypeReusableComponent = isTypeReusableComponent;
+const helpers_1 = require("./helpers");
+const reusable_outline_1 = require("./component/reusable.outline");
+/*
+ * The functions starting with 'isType*' use typescript narrowing to check the value
+ * see: https://www.typescriptlang.org/docs/handbook/2/narrowing.html
+ */
+/**
+ * Check if the item is a field definition (it has at least 'class' and optional 'config' properties).
+ * @param item The item to check.
+ */
+function isTypeFieldDefinition(item) {
+    if (item === undefined || item === null) {
+        return false;
+    }
+    const i = item;
+    const propClassGuessType = (0, helpers_1.guessType)(i?.class);
+    const hasExpectedPropClass = 'class' in i && propClassGuessType === 'string';
+    // 'config' can be null or object or not set
+    const propConfigGuessType = (0, helpers_1.guessType)(i.config);
+    const hasExpectedPropConfig = ('config' in i && ["object", "null"].includes(propConfigGuessType)) || i?.config === undefined;
+    const isFieldDefinition = hasExpectedPropClass && hasExpectedPropConfig;
+    if (!isFieldDefinition) {
+        console.log(`isTypeFieldDefinition propClassGuessType ${propClassGuessType} propConfigGuessType ${propConfigGuessType}`);
+    }
+    return isFieldDefinition;
+}
+/**
+ * Check if the item is a field definition of a particular type by comparing the class name
+ * (class name is the discriminator in the type union).
+ * @param item The item to check.
+ * @param name The class name to check.
+ */
+function isTypeFieldDefinitionName(item, name) {
+    if (item === undefined || item === null) {
+        return false;
+    }
+    const hasExpectedFieldDefClass = isTypeFieldDefinition(item) && item?.class === name;
+    return hasExpectedFieldDefClass;
+}
+/**
+ * Check if the item is a form component definition (it has at least 'name' and 'component' properties).
+ * @param item The item to check.
+ */
+function isTypeFormComponentDefinition(item) {
+    if (item === undefined || item === null) {
+        return false;
+    }
+    // use typescript narrowing to check the value
+    const i = item;
+    // only name and component are required
+    const hasName = 'name' in i;
+    const hasExpectedNameValue = ["null", "string"].includes((0, helpers_1.guessType)(i?.name));
+    const hasComponent = 'component' in i;
+    const isFormFieldComponent = isTypeFieldDefinition(i?.component);
+    return hasName && hasExpectedNameValue && hasComponent && isFormFieldComponent;
+}
+/**
+ * Check if the item is a form definition of a particular type by comparing the component class
+ * (component class name is the discriminator in the type union).
+ * @param item The item to check.
+ * @param name The class name to check.
+ */
+function isTypeFormComponentDefinitionName(item, name) {
+    if (item === undefined || item === null) {
+        return false;
+    }
+    const hasExpectedFormDefClass = isTypeFormComponentDefinition(item) && item?.component?.class === name;
+    return hasExpectedFormDefClass;
+}
+/**
+ * Check if the item has a componentDefinitions array property.
+ * @param item The item to check.
+ */
+function isTypeWithComponentDefinitions(item) {
+    if (item === undefined || item === null) {
+        return false;
+    }
+    // use typescript narrowing to check the value
+    const i = item;
+    const hasExpectedPropCompDefs = 'componentDefinitions' in i && (0, helpers_1.guessType)(i?.componentDefinitions) === 'array';
+    return hasExpectedPropCompDefs;
+}
+/**
+ * Check if the item is a FormConfig (it has a name and componentDefinitions array property).
+ * @param item The item to check.
+ */
+function isTypeFormConfig(item) {
+    if (item === undefined || item === null) {
+        return false;
+    }
+    const i = item;
+    const hasExpectedPropName = 'name' in i && (0, helpers_1.guessType)(i.name) === 'string';
+    const hasExpectedPropCompDefs = isTypeWithComponentDefinitions(item);
+    return hasExpectedPropName && hasExpectedPropCompDefs;
+}
+/**
+ * Check if a form component definition specifies to use a reusable form config.
+ * @param item The form component definition.
+ * @param reusableFormDefNames The names of the available reusable form definitions.
+ * @protected
+ */
+function isTypeReusableComponent(item, reusableFormDefNames) {
+    const componentClassName = item?.component?.class ?? "";
+    const itemReusableFormName = item?.overrides?.reusableFormName ?? "";
+    const isReusableComponent = componentClassName === reusable_outline_1.ReusableComponentName;
+    const hasReusableFormName = itemReusableFormName && reusableFormDefNames.includes(itemReusableFormName);
+    if (!isReusableComponent && !hasReusableFormName) {
+        return false;
+    }
+    if (hasReusableFormName && isTypeFormComponentDefinitionName(item, reusable_outline_1.ReusableComponentName)) {
+        const overrides = item?.overrides ?? {};
+        const overrideKeys = Object.keys(overrides);
+        const reusableFormNameOnly = overrideKeys.includes('reusableFormName') && overrideKeys.length === 1;
+        const noKeys = overrideKeys.length === 0;
+        if (!reusableFormNameOnly && !noKeys) {
+            throw new Error("Invalid usage of reusable form config. " +
+                `Override for component name '${item.name}' class '${item.component.class}' must contain only 'reusableFormName', ` +
+                `it cannot be combined with other properties '${JSON.stringify(overrides)}'. ` +
+                `Change the form component name by setting the 'replaceName' property for the relevant componentDefinition. ` +
+                `The 'formModeClasses' can only be changed on subcomponents.`);
+        }
+        return true;
+    }
+    throw new Error("Invalid usage of reusable form config. " +
+        `Component class '${componentClassName}' must be '${reusable_outline_1.ReusableComponentName}' ` +
+        `and reusableFormName '${itemReusableFormName}' must be one of '${reusableFormDefNames.join(', ') || '(none available)'}'.`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/config/helpers.d.ts

@@ -0,0 +1,31 @@
+export type GuessedType = "null" | "undefined" | "boolean" | "number" | "array" | "object" | "function" | "timestamp" | "string" | "unknown";
+/**
+ * Guess the type of the value.
+ * @param value Guess the type of this value.
+ * @private
+ */
+export declare function guessType(value: unknown): GuessedType;
+/**
+ * Apply conventions to convert a value to a boolean.
+ * @param value A value to convert to boolean.
+ */
+export declare function toBoolean(value: unknown): boolean;
+/**
+ * Check whether a 'check' array starts with a 'base' array.
+ * Both arrays must have at least one element.
+ * @param base The shorter array.
+ * @param check The longer array.
+ * @private
+ */
+export declare function arrayStartsWithArray(base: unknown[], check: unknown[]): boolean;
+/**
+ * Extract all properties of the type T that are of the type U.
+ */
+export type ExtractPropertyNamesOfType<T, U> = {
+    [K in keyof T]: T[K] extends U ? K : never;
+}[keyof T];
+/**
+ * Extract all properties from each of the types in the union type T, where the properties are of type U.
+ * This uses the distributive feature of conditional types (T extends T ? ...).
+ */
+export type ExtractPropertyNamesOfTypeFromTypeUnion<T, U> = T extends T ? ExtractPropertyNamesOfType<T, U> : never;

package/dist/src/config/helpers.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessType = guessType;
+exports.toBoolean = toBoolean;
+exports.arrayStartsWithArray = arrayStartsWithArray;
+const lodash_1 = require("lodash");
+const luxon_1 = require("luxon");
+/**
+ * Guess the type of the value.
+ * @param value Guess the type of this value.
+ * @private
+ */
+function guessType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (value === undefined) {
+        return "undefined";
+    }
+    if ((0, lodash_1.isBoolean)(value)) {
+        return "boolean";
+    }
+    if (Number.isFinite(value)) {
+        return "number";
+    }
+    if ((0, lodash_1.isArray)(value)) {
+        return "array";
+    }
+    if ((0, lodash_1.isPlainObject)(value)) {
+        return "object";
+    }
+    // Check for custom Object.
+    try {
+        const valueInfo = valueProtoInfo(value);
+        if (valueInfo.isObjectLike && valueInfo.isValueStringTagObject &&
+            valueInfo.isValueProtoCtorFunc && !valueInfo.isValueProtoCtorFuncObj) {
+            return "object";
+        }
+    }
+    catch (err) {
+        console.debug(`guessType custom object error with value '${value}': ${err}`);
+    }
+    if ((0, lodash_1.isFunction)(value)) {
+        return "function";
+    }
+    // check for date
+    const dateTimeFormats = [
+        luxon_1.DateTime.fromISO,
+        luxon_1.DateTime.fromRFC2822,
+        luxon_1.DateTime.fromHTTP,
+    ];
+    try {
+        for (const dateTimeFormat of dateTimeFormats) {
+            const result = dateTimeFormat(value?.toString() ?? "");
+            if (result && result.isValid) {
+                return "timestamp";
+            }
+        }
+    }
+    catch (err) {
+        console.debug(`guessType parse error with value '${value}' formats ${JSON.stringify(dateTimeFormats)}: ${err}`);
+    }
+    if ((0, lodash_1.isString)(value)) {
+        return "string";
+    }
+    console.debug(`guessType unknown type for '${value}' info ${JSON.stringify(valueProtoInfo(value))}`);
+    return "unknown";
+}
+function valueProtoInfo(value) {
+    const isObjectLike = (0, lodash_1.isObjectLike)(value);
+    const isValueStringTagObject = Object.prototype.toString.call(value) === '[object Object]';
+    const valuePrototypeCtor = Object.getPrototypeOf(value).constructor;
+    const isValueProtoCtorFunc = typeof valuePrototypeCtor === 'function';
+    const isValueProtoCtorFuncObj = Function.prototype.toString.call(valuePrototypeCtor) === Function.prototype.toString.call(Object);
+    return {
+        isObjectLike,
+        isValueStringTagObject,
+        valuePrototypeCtor,
+        isValueProtoCtorFunc,
+        isValueProtoCtorFuncObj,
+    };
+}
+/**
+ * Apply conventions to convert a value to a boolean.
+ * @param value A value to convert to boolean.
+ */
+function toBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return !Number.isNaN(value) && value !== 0;
+    }
+    const normalized = String(value ?? '').trim().toLowerCase();
+    const trueValues = ["true", "t", "1", "yes", "y", "on", "enable", "enabled"];
+    return trueValues.includes(normalized);
+}
+/**
+ * Check whether a 'check' array starts with a 'base' array.
+ * Both arrays must have at least one element.
+ * @param base The shorter array.
+ * @param check The longer array.
+ * @private
+ */
+function arrayStartsWithArray(base, check) {
+    if (!base || !check) {
+        return false;
+    }
+    if (base.length > check.length) {
+        return false;
+    }
+    return base.every((value, index) => check[index] === value);
+}
+// TODO: consider trying to type the access to the config properties.
+// type FormFieldComponentOrLayoutDefinitionConfig = FormFieldComponentOrLayoutDefinition['config'];
+// type FormFieldComponentOrLayoutStringKeys = NonNullable<ExtractPropertyNamesOfTypeFromTypeUnion<
+//   FormFieldComponentOrLayoutDefinitionConfig, string | undefined | null
+// >>;
+// type FormFieldComponentOrLayoutBooleanKeys = NonNullable<ExtractPropertyNamesOfTypeFromTypeUnion<
+//   FormFieldComponentOrLayoutDefinitionConfig, boolean | undefined | null
+// >>;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/config/names/naming-helpers.d.ts

@@ -0,0 +1,112 @@
+/**
+ * A lineage path is an ordered list of keys (string|number) describing a path lineage for
+ * different domains of form configuration.
+ * A string key is a property name or array index number as a string, a number key is an array index.
+ */
+export type LineagePath = (string | number)[];
+/**
+ * A collection of lineage paths that describe different relationships.
+ */
+export interface LineagePaths {
+    /**
+     * The path to the item in the form config.
+     */
+    formConfig: LineagePath;
+    /**
+     * The path to the item in the form data model.
+     */
+    dataModel: LineagePath;
+    /**
+     * The path to the item in the angular control hierarchy.
+     */
+    angularComponents: LineagePath;
+    /**
+     * The JSONPointer to the angular control.
+     */
+    angularComponentsJsonPointer?: string;
+    /**
+     * The path to the item in the layout hierarchy.
+     * Uses the component name with a "-layout" suffix.
+     */
+    layout: LineagePath;
+    /**
+     * The JSONPointer to the layout item.
+     */
+    layoutJsonPointer?: string;
+}
+/**
+ * Allow providing a partial lineage paths object.
+ * This is for adding to an existing lineage path.
+ *
+ * This does not include the calculated json pointer fields on purpose.
+ * Use LineagePathsOptional to include the json pointer fields.
+ */
+export interface LineagePathsPartial {
+    formConfig?: LineagePath;
+    dataModel?: LineagePath;
+    angularComponents?: LineagePath;
+    layout?: LineagePath;
+}
+/**
+ * Allow providing any of the lineage paths properties.
+ *
+ * This does include the calculated json pointer fields on purpose.
+ * Use LineagePathsPartial to include only the fields that are not calculated.
+ */
+export type LineagePathsOptional = Partial<LineagePaths>;
+/**
+ * Build the lineage paths from a base item, and add the entries in `more` as relative
+ * parts at the end of each lineage path. Undefined inputs default to empty arrays.
+ * This was previously an instance method of FormService.
+ */
+export declare function buildLineagePaths(base?: LineagePaths, more?: LineagePathsPartial): LineagePaths;
+/**
+ * Get a JSON Pointer string from an array of path segments.
+ *
+ * @param paths
+ * @returns JSON Pointer string
+ */
+export declare function getJSONPointerByArrayPaths(paths: (string | number)[]): string;
+/**
+ * Retrieve any object property using a JSON Pointer or an array of path segments.
+ *
+ * @param obj
+ * @param pointer
+ * @returns JSON Pointer reference: {key: 'key', val: 'object value at key', obj: 'context object, 1 level up from key'}
+ */
+export declare function getObjectWithJsonPointer(obj: any, pointer: string | string[]): any;
+/**
+ * Retrieve the last segment of a JSONPointer string
+ */
+export declare function getLastSegmentFromJSONPointer(pointer: string): string;
+/**
+ * Normalise a string to reduce the potential variations in how characters are specified.
+ *
+ * @param value The value to normalise.
+ * @return The string normalised to remove visual variants.
+ */
+export declare function normaliseVisual(value: unknown): string;
+/**
+ * Determine if every key present in both lineage paths match.
+ * @param a The first lineage paths object.
+ * @param b The second lineage paths object.
+ */
+export declare function isMatchingLineagePaths(a: LineagePathsOptional, b: LineagePathsOptional): boolean;
+/**
+ * Determine if two lineage paths or strings are equal.
+ * @param a The first lineage path or string.
+ * @param b The second lineage path or string.
+ */
+export declare function isMatchingLineagePath(a: LineagePath | string, b: LineagePath | string): boolean;
+/**
+ * Determine if every key (present in both lineage paths) of a lineage path starts with a base lineage path.
+ * @param base The prefix lineage paths object.
+ * @param check The lineage paths object that should start with the prefix.
+ */
+export declare function isPrefixLineagePaths(base: LineagePathsOptional, check: LineagePathsOptional): boolean;
+/**
+ * Determine if a check lineage path starts with a base lineage path.
+ * @param base The prefix.
+ * @param check The item that should start with prefix.
+ */
+export declare function isPrefixLineagePath(base: LineagePath | string, check: LineagePath | string): boolean;