@limetech/lime-web-components 5.39.0 → 5.40.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [5.40.0](https://github.com/Lundalogik/lime-web-components/compare/v5.39.0...v5.40.0) (2024-11-21)
+
+
+### Features
+
+
+* **limetype:** add helper functions for working with limetypes ([70c0cba](https://github.com/Lundalogik/lime-web-components/commit/70c0cbadc3e23794b8236d973ebf789803e71d02))
+
 ## [5.39.0](https://github.com/Lundalogik/lime-web-components/compare/v5.38.1...v5.39.0) (2024-11-21)
 
 

package/dist/es5/limetype/find-limetype-by-label.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLimetypeByLabel = void 0;
+var _1 = require(".");
+var findLimetypeByLabel = function (label) { return function (limetypes) {
+    return Object.values(limetypes).find((0, _1.hasLabel)(label));
+}; };
+exports.findLimetypeByLabel = findLimetypeByLabel;

package/dist/es5/limetype/find-limetype-by-label.spec.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var company_1 = require("../testing/limetypes/company");
+var person_1 = require("../testing/limetypes/person");
+var find_limetype_by_label_1 = require("./find-limetype-by-label");
+describe('findLimetypeByLabel', function () {
+    var limetypes = {
+        company: tslib_1.__assign({}, company_1.company),
+        person: tslib_1.__assign({}, person_1.person),
+    };
+    it('returns a function', function () {
+        var result = (0, find_limetype_by_label_1.findLimetypeByLabel)('person');
+        expect(typeof result).toBe('function');
+    });
+    describe('when the label exists', function () {
+        it('returns the correct limetype', function () {
+            var findUser = (0, find_limetype_by_label_1.findLimetypeByLabel)('person');
+            var result = findUser(limetypes);
+            expect(result).toStrictEqual(person_1.person);
+        });
+    });
+    describe('when the label does not exist', function () {
+        it('returns undefined', function () {
+            var findNonexistent = (0, find_limetype_by_label_1.findLimetypeByLabel)('nonexistent');
+            var result = findNonexistent(limetypes);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('when the limetypes object is empty', function () {
+        it('returns undefined', function () {
+            var findUser = (0, find_limetype_by_label_1.findLimetypeByLabel)('person');
+            var result = findUser({});
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('when the input is invalid', function () {
+        it('throws an error if limetypes is null', function () {
+            var findUser = (0, find_limetype_by_label_1.findLimetypeByLabel)('person');
+            expect(function () { return findUser(null); }).toThrow();
+        });
+        it('throws an error if limetypes is undefined', function () {
+            var findUser = (0, find_limetype_by_label_1.findLimetypeByLabel)('person');
+            expect(function () { return findUser(undefined); }).toThrow();
+        });
+    });
+});

package/dist/es5/limetype/get-properties-by-type.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertiesByType = void 0;
+function getPropertiesByType(limetype, type) {
+    return Object.values(limetype.properties).filter(function (property) { return property.type === type; });
+}
+exports.getPropertiesByType = getPropertiesByType;

package/dist/es5/limetype/get-properties-by-type.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var person_1 = require("../testing/limetypes/person");
+var get_properties_by_type_1 = require("./get-properties-by-type");
+describe('getPropertiesByType', function () {
+    it('retrieves all properties of a specified type', function () {
+        var result = (0, get_properties_by_type_1.getPropertiesByType)(tslib_1.__assign({}, person_1.person), 'string');
+        expect(result).toStrictEqual([
+            person_1.person.properties.firstname,
+            person_1.person.properties.lastname,
+            person_1.person.properties.name,
+            person_1.person.properties.position,
+        ]);
+    });
+    it('returns an empty array if no properties match the type', function () {
+        var result = (0, get_properties_by_type_1.getPropertiesByType)(tslib_1.__assign({}, person_1.person), 'integer');
+        expect(result).toStrictEqual([]);
+    });
+    describe('edge cases', function () {
+        it('returns an empty array if limetype has no properties', function () {
+            var emptyLimetype = {
+                label: 'empty',
+                properties: {},
+            };
+            var result = (0, get_properties_by_type_1.getPropertiesByType)(emptyLimetype, 'string');
+            expect(result).toStrictEqual([]);
+        });
+        it('throws an error if limetype is null or undefined', function () {
+            expect(function () { return (0, get_properties_by_type_1.getPropertiesByType)(null, 'string'); }).toThrow();
+            expect(function () {
+                return (0, get_properties_by_type_1.getPropertiesByType)(undefined, 'string');
+            }).toThrow();
+        });
+    });
+});

package/dist/es5/limetype/get-property-by-label.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertyByLabel = void 0;
+var _1 = require(".");
+function getPropertyByLabel(limetype, label) {
+    return Object.values(limetype.properties).find((0, _1.hasLabel)(label));
+}
+exports.getPropertyByLabel = getPropertyByLabel;

package/dist/es5/limetype/get-property-by-label.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var person_1 = require("../testing/limetypes/person");
+var get_property_by_label_1 = require("./get-property-by-label");
+describe('getPropertyByLabel', function () {
+    it('retrieves a property by its label', function () {
+        var result = (0, get_property_by_label_1.getPropertyByLabel)(tslib_1.__assign({}, person_1.person), 'primaryemailaddress');
+        expect(result).toStrictEqual(person_1.person.properties.email);
+    });
+    it('returns undefined if no property matches the label', function () {
+        var result = (0, get_property_by_label_1.getPropertyByLabel)(tslib_1.__assign({}, person_1.person), 'nonexistent');
+        expect(result).toBeUndefined();
+    });
+    describe('edge cases', function () {
+        it('returns undefined if limetype has no properties', function () {
+            var emptyLimetype = {
+                label: 'empty',
+                properties: {},
+            };
+            var result = (0, get_property_by_label_1.getPropertyByLabel)(emptyLimetype, 'primaryemailaddress');
+            expect(result).toBeUndefined();
+        });
+        it('throws an error if limetype is null or undefined', function () {
+            expect(function () {
+                return (0, get_property_by_label_1.getPropertyByLabel)(null, 'primaryemailaddress');
+            }).toThrow();
+            expect(function () {
+                return (0, get_property_by_label_1.getPropertyByLabel)(undefined, 'primaryemailaddress');
+            }).toThrow();
+        });
+    });
+});

package/dist/es5/limetype/get-property-by-name.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertyByName = void 0;
+function getPropertyByName(limetype, propertyName) {
+    return limetype.properties[propertyName];
+}
+exports.getPropertyByName = getPropertyByName;

package/dist/es5/limetype/get-property-by-name.spec.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var person_1 = require("../testing/limetypes/person");
+var get_property_by_name_1 = require("./get-property-by-name");
+describe('getPropertyByName', function () {
+    it('retrieves a property by its name', function () {
+        var result = (0, get_property_by_name_1.getPropertyByName)(tslib_1.__assign({}, person_1.person), 'email');
+        expect(result).toStrictEqual(person_1.person.properties.email);
+    });
+    it('returns `undefined` if the property does not exist', function () {
+        var result = (0, get_property_by_name_1.getPropertyByName)(tslib_1.__assign({}, person_1.person), 'age');
+        expect(result).toBeUndefined();
+    });
+    describe('edge cases', function () {
+        it('returns undefined if limetype has no properties', function () {
+            var emptyLimetype = {
+                label: 'Empty',
+                properties: {},
+            };
+            var result = (0, get_property_by_name_1.getPropertyByName)(emptyLimetype, 'email');
+            expect(result).toBeUndefined();
+        });
+        it('throws an error if limetype is null or undefined', function () {
+            expect(function () { return (0, get_property_by_name_1.getPropertyByName)(null, 'email'); }).toThrow();
+            expect(function () {
+                return (0, get_property_by_name_1.getPropertyByName)(undefined, 'email');
+            }).toThrow();
+        });
+    });
+});

package/dist/es5/limetype/has-label.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasLabel = void 0;
+var hasLabel = function (label) { return function (object) {
+    return (object === null || object === void 0 ? void 0 : object.label) === label;
+}; };
+exports.hasLabel = hasLabel;

package/dist/es5/limetype/has-label.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var person_1 = require("../testing/limetypes/person");
+var has_label_1 = require("./has-label");
+describe('hasLabel', function () {
+    it('returns true if the object has the specified label', function () {
+        var checkLabel = (0, has_label_1.hasLabel)('primaryemailaddress');
+        expect(checkLabel(person_1.person.properties.email)).toBe(true);
+    });
+    it('returns false if the object does not have the specified label', function () {
+        var checkLabel = (0, has_label_1.hasLabel)('firstname');
+        expect(checkLabel(person_1.person.properties.email)).toBe(false);
+    });
+    it('returns false if the object is undefined', function () {
+        var checkLabel = (0, has_label_1.hasLabel)('firstname');
+        expect(checkLabel(undefined)).toBe(false);
+    });
+    describe('edge cases', function () {
+        it('returns false if the object has no label property', function () {
+            var obj = { type: 'string' };
+            var checkLabel = (0, has_label_1.hasLabel)('firstname');
+            expect(checkLabel(obj)).toBe(false);
+        });
+        it.skip('returns false if the label is an empty string', function () {
+            var obj = { label: '', type: 'string' };
+            var checkLabel = (0, has_label_1.hasLabel)('');
+            expect(checkLabel(obj)).toBe(false);
+        });
+    });
+});

package/dist/es5/limetype/index.js

@@ -7,3 +7,8 @@ tslib_1.__exportStar(require("./property"), exports);
 tslib_1.__exportStar(require("./repository"), exports);
 tslib_1.__exportStar(require("./types"), exports);
 tslib_1.__exportStar(require("./decorator"), exports);
+tslib_1.__exportStar(require("./find-limetype-by-label"), exports);
+tslib_1.__exportStar(require("./get-properties-by-type"), exports);
+tslib_1.__exportStar(require("./get-property-by-label"), exports);
+tslib_1.__exportStar(require("./get-property-by-name"), exports);
+tslib_1.__exportStar(require("./has-label"), exports);

package/dist/limetype/find-limetype-by-label.d.ts

@@ -0,0 +1,42 @@
+import { LimeType } from '.';
+/**
+ * Creates a function to find a limetype by its label in a collection of limetypes.
+ *
+ * The returned function searches through a collection of limetypes and returns
+ * the first one that matches the given label. This function is typically used
+ * to generate a callback for decorators or other higher-order logic.
+ *
+ * @param label - The label of the limetype to find.
+ * @returns A function that takes a collection of limetypes and returns the first
+ * limetype that matches the label, or `undefined` if no match is found.
+ *
+ * @example
+ * ```typescript
+ * import { findLimetypeByLabel } from '@limetech/lime-web-components';
+ *
+ * const limetypes = {
+ *     company: { label: 'company', properties: {} },
+ *     person: { label: 'person', properties: {} },
+ * };
+ *
+ * const findPersonLimetype = findLimetypeByLabel('person');
+ * const personLimetype = findPersonLimetype(limetypes);
+ * console.log(personLimetype); // { label: 'person', properties: {} }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using `findLimetypeByLabel` as a callback for a decorator
+ * import { findLimetypeByLabel, SelectLimeTypes } from '@limetech/lime-web-components';
+ *
+ * @SelectLimeTypes({
+ *     map: [findLimetypeByLabel('person')],
+ * })
+ * private personLimetype: LimeType;
+ * ```
+ *
+ * @public
+ * @group Lime types
+ */
+export declare const findLimetypeByLabel: (label: string) => (limetypes: Record<string, LimeType>) => LimeType;
+//# sourceMappingURL=find-limetype-by-label.d.ts.map

package/dist/limetype/find-limetype-by-label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-limetype-by-label.d.ts","sourceRoot":"","sources":["../../src/limetype/find-limetype-by-label.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,GAAG,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mBAAmB,UACpB,MAAM,iBAAiB,OAAO,MAAM,EAAE,QAAQ,CAAC,aAEtD,CAAC"}

package/dist/limetype/find-limetype-by-label.js

@@ -0,0 +1,43 @@
+import { hasLabel } from '.';
+/**
+ * Creates a function to find a limetype by its label in a collection of limetypes.
+ *
+ * The returned function searches through a collection of limetypes and returns
+ * the first one that matches the given label. This function is typically used
+ * to generate a callback for decorators or other higher-order logic.
+ *
+ * @param label - The label of the limetype to find.
+ * @returns A function that takes a collection of limetypes and returns the first
+ * limetype that matches the label, or `undefined` if no match is found.
+ *
+ * @example
+ * ```typescript
+ * import { findLimetypeByLabel } from '@limetech/lime-web-components';
+ *
+ * const limetypes = {
+ *     company: { label: 'company', properties: {} },
+ *     person: { label: 'person', properties: {} },
+ * };
+ *
+ * const findPersonLimetype = findLimetypeByLabel('person');
+ * const personLimetype = findPersonLimetype(limetypes);
+ * console.log(personLimetype); // { label: 'person', properties: {} }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using `findLimetypeByLabel` as a callback for a decorator
+ * import { findLimetypeByLabel, SelectLimeTypes } from '@limetech/lime-web-components';
+ *
+ * @SelectLimeTypes({
+ *     map: [findLimetypeByLabel('person')],
+ * })
+ * private personLimetype: LimeType;
+ * ```
+ *
+ * @public
+ * @group Lime types
+ */
+export const findLimetypeByLabel = (label) => (limetypes) => {
+    return Object.values(limetypes).find(hasLabel(label));
+};

package/dist/limetype/find-limetype-by-label.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=find-limetype-by-label.spec.d.ts.map

package/dist/limetype/find-limetype-by-label.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-limetype-by-label.spec.d.ts","sourceRoot":"","sources":["../../src/limetype/find-limetype-by-label.spec.ts"],"names":[],"mappings":""}

package/dist/limetype/find-limetype-by-label.spec.js

@@ -0,0 +1,44 @@
+import { company } from '../testing/limetypes/company';
+import { person } from '../testing/limetypes/person';
+import { findLimetypeByLabel } from './find-limetype-by-label';
+describe('findLimetypeByLabel', () => {
+    const limetypes = {
+        company: Object.assign({}, company),
+        person: Object.assign({}, person),
+    };
+    it('returns a function', () => {
+        const result = findLimetypeByLabel('person');
+        expect(typeof result).toBe('function');
+    });
+    describe('when the label exists', () => {
+        it('returns the correct limetype', () => {
+            const findUser = findLimetypeByLabel('person');
+            const result = findUser(limetypes);
+            expect(result).toStrictEqual(person);
+        });
+    });
+    describe('when the label does not exist', () => {
+        it('returns undefined', () => {
+            const findNonexistent = findLimetypeByLabel('nonexistent');
+            const result = findNonexistent(limetypes);
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('when the limetypes object is empty', () => {
+        it('returns undefined', () => {
+            const findUser = findLimetypeByLabel('person');
+            const result = findUser({});
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('when the input is invalid', () => {
+        it('throws an error if limetypes is null', () => {
+            const findUser = findLimetypeByLabel('person');
+            expect(() => findUser(null)).toThrow();
+        });
+        it('throws an error if limetypes is undefined', () => {
+            const findUser = findLimetypeByLabel('person');
+            expect(() => findUser(undefined)).toThrow();
+        });
+    });
+});

package/dist/limetype/get-properties-by-type.d.ts

@@ -0,0 +1,16 @@
+import { LimeProperty, LimeType, PropertyType } from '.';
+/**
+ * Retrieves all properties of a specific type from a limetype.
+ *
+ * This function filters the properties of a limetype and returns
+ * those that match the specified property type.
+ *
+ * @param limetype - The limetype containing the properties.
+ * @param type - The type of properties to retrieve.
+ * @returns An array of properties that match the specified type.
+ *
+ * @public
+ * @group Lime types
+ */
+export declare function getPropertiesByType(limetype: LimeType, type: PropertyType): LimeProperty[];
+//# sourceMappingURL=get-properties-by-type.d.ts.map

package/dist/limetype/get-properties-by-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-properties-by-type.d.ts","sourceRoot":"","sources":["../../src/limetype/get-properties-by-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,GAAG,CAAC;AAEzD;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,YAAY,GACnB,YAAY,EAAE,CAIhB"}

package/dist/limetype/get-properties-by-type.js

@@ -0,0 +1,16 @@
+/**
+ * Retrieves all properties of a specific type from a limetype.
+ *
+ * This function filters the properties of a limetype and returns
+ * those that match the specified property type.
+ *
+ * @param limetype - The limetype containing the properties.
+ * @param type - The type of properties to retrieve.
+ * @returns An array of properties that match the specified type.
+ *
+ * @public
+ * @group Lime types
+ */
+export function getPropertiesByType(limetype, type) {
+    return Object.values(limetype.properties).filter((property) => property.type === type);
+}

package/dist/limetype/get-properties-by-type.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-properties-by-type.spec.d.ts.map

package/dist/limetype/get-properties-by-type.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-properties-by-type.spec.d.ts","sourceRoot":"","sources":["../../src/limetype/get-properties-by-type.spec.ts"],"names":[],"mappings":""}

package/dist/limetype/get-properties-by-type.spec.js

@@ -0,0 +1,31 @@
+import { person } from '../testing/limetypes/person';
+import { getPropertiesByType } from './get-properties-by-type';
+describe('getPropertiesByType', () => {
+    it('retrieves all properties of a specified type', () => {
+        const result = getPropertiesByType(Object.assign({}, person), 'string');
+        expect(result).toStrictEqual([
+            person.properties.firstname,
+            person.properties.lastname,
+            person.properties.name,
+            person.properties.position,
+        ]);
+    });
+    it('returns an empty array if no properties match the type', () => {
+        const result = getPropertiesByType(Object.assign({}, person), 'integer');
+        expect(result).toStrictEqual([]);
+    });
+    describe('edge cases', () => {
+        it('returns an empty array if limetype has no properties', () => {
+            const emptyLimetype = {
+                label: 'empty',
+                properties: {},
+            };
+            const result = getPropertiesByType(emptyLimetype, 'string');
+            expect(result).toStrictEqual([]);
+        });
+        it('throws an error if limetype is null or undefined', () => {
+            expect(() => getPropertiesByType(null, 'string')).toThrow();
+            expect(() => getPropertiesByType(undefined, 'string')).toThrow();
+        });
+    });
+});

package/dist/limetype/get-property-by-label.d.ts

@@ -0,0 +1,16 @@
+import { LimeProperty, LimeType } from '.';
+/**
+ * Retrieves a property from a limetype by its label.
+ *
+ * This function searches through the properties of a given limetype
+ * and returns the first property that matches the specified label.
+ *
+ * @param limetype - The limetype containing the properties.
+ * @param label - The label of the property to retrieve.
+ * @returns The property with the specified label, or `undefined` if no match is found.
+ *
+ * @public
+ * @group Lime types
+ */
+export declare function getPropertyByLabel(limetype: LimeType, label: string): LimeProperty | undefined;
+//# sourceMappingURL=get-property-by-label.d.ts.map

package/dist/limetype/get-property-by-label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-property-by-label.d.ts","sourceRoot":"","sources":["../../src/limetype/get-property-by-label.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GACd,YAAY,GAAG,SAAS,CAE1B"}

package/dist/limetype/get-property-by-label.js

@@ -0,0 +1,17 @@
+import { hasLabel } from '.';
+/**
+ * Retrieves a property from a limetype by its label.
+ *
+ * This function searches through the properties of a given limetype
+ * and returns the first property that matches the specified label.
+ *
+ * @param limetype - The limetype containing the properties.
+ * @param label - The label of the property to retrieve.
+ * @returns The property with the specified label, or `undefined` if no match is found.
+ *
+ * @public
+ * @group Lime types
+ */
+export function getPropertyByLabel(limetype, label) {
+    return Object.values(limetype.properties).find(hasLabel(label));
+}

package/dist/limetype/get-property-by-label.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-property-by-label.spec.d.ts.map

package/dist/limetype/get-property-by-label.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-property-by-label.spec.d.ts","sourceRoot":"","sources":["../../src/limetype/get-property-by-label.spec.ts"],"names":[],"mappings":""}

package/dist/limetype/get-property-by-label.spec.js

@@ -0,0 +1,26 @@
+import { person } from '../testing/limetypes/person';
+import { getPropertyByLabel } from './get-property-by-label';
+describe('getPropertyByLabel', () => {
+    it('retrieves a property by its label', () => {
+        const result = getPropertyByLabel(Object.assign({}, person), 'primaryemailaddress');
+        expect(result).toStrictEqual(person.properties.email);
+    });
+    it('returns undefined if no property matches the label', () => {
+        const result = getPropertyByLabel(Object.assign({}, person), 'nonexistent');
+        expect(result).toBeUndefined();
+    });
+    describe('edge cases', () => {
+        it('returns undefined if limetype has no properties', () => {
+            const emptyLimetype = {
+                label: 'empty',
+                properties: {},
+            };
+            const result = getPropertyByLabel(emptyLimetype, 'primaryemailaddress');
+            expect(result).toBeUndefined();
+        });
+        it('throws an error if limetype is null or undefined', () => {
+            expect(() => getPropertyByLabel(null, 'primaryemailaddress')).toThrow();
+            expect(() => getPropertyByLabel(undefined, 'primaryemailaddress')).toThrow();
+        });
+    });
+});

package/dist/limetype/get-property-by-name.d.ts

@@ -0,0 +1,17 @@
+import { LimeProperty, LimeType } from '.';
+/**
+ * Retrieves a property from a limetype by its name.
+ *
+ * This function extracts a specific property from a given limetype
+ * based on the property's name.
+ *
+ * @param limetype - The limetype containing the properties.
+ * @param propertyName - The name of the property to retrieve.
+ * @returns The property with the specified name.
+ * @throws Will throw an error if the property name does not exist in the limetype.
+ *
+ * @public
+ * @group Lime types
+ */
+export declare function getPropertyByName(limetype: LimeType, propertyName: string): LimeProperty;
+//# sourceMappingURL=get-property-by-name.d.ts.map

package/dist/limetype/get-property-by-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-property-by-name.d.ts","sourceRoot":"","sources":["../../src/limetype/get-property-by-name.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC;AAE3C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC7B,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,MAAM,GACrB,YAAY,CAEd"}

package/dist/limetype/get-property-by-name.js

@@ -0,0 +1,17 @@
+/**
+ * Retrieves a property from a limetype by its name.
+ *
+ * This function extracts a specific property from a given limetype
+ * based on the property's name.
+ *
+ * @param limetype - The limetype containing the properties.
+ * @param propertyName - The name of the property to retrieve.
+ * @returns The property with the specified name.
+ * @throws Will throw an error if the property name does not exist in the limetype.
+ *
+ * @public
+ * @group Lime types
+ */
+export function getPropertyByName(limetype, propertyName) {
+    return limetype.properties[propertyName];
+}

package/dist/limetype/get-property-by-name.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-property-by-name.spec.d.ts.map

package/dist/limetype/get-property-by-name.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-property-by-name.spec.d.ts","sourceRoot":"","sources":["../../src/limetype/get-property-by-name.spec.ts"],"names":[],"mappings":""}

package/dist/limetype/get-property-by-name.spec.js

@@ -0,0 +1,26 @@
+import { person } from '../testing/limetypes/person';
+import { getPropertyByName } from './get-property-by-name';
+describe('getPropertyByName', () => {
+    it('retrieves a property by its name', () => {
+        const result = getPropertyByName(Object.assign({}, person), 'email');
+        expect(result).toStrictEqual(person.properties.email);
+    });
+    it('returns `undefined` if the property does not exist', () => {
+        const result = getPropertyByName(Object.assign({}, person), 'age');
+        expect(result).toBeUndefined();
+    });
+    describe('edge cases', () => {
+        it('returns undefined if limetype has no properties', () => {
+            const emptyLimetype = {
+                label: 'Empty',
+                properties: {},
+            };
+            const result = getPropertyByName(emptyLimetype, 'email');
+            expect(result).toBeUndefined();
+        });
+        it('throws an error if limetype is null or undefined', () => {
+            expect(() => getPropertyByName(null, 'email')).toThrow();
+            expect(() => getPropertyByName(undefined, 'email')).toThrow();
+        });
+    });
+});

package/dist/limetype/has-label.d.ts

@@ -0,0 +1,29 @@
+import { LimeProperty, LimeType } from '.';
+/**
+ * Creates a function to check if a given object has a specific label.
+ *
+ * The returned function takes an object (a `LimeType` or `LimeProperty`) and
+ * checks whether it contains the specified label. This function is typically
+ * used as a callback for array methods like `.find` or `.filter`.
+ *
+ * @param label - The label to check for.
+ * @returns A function that takes an optional object and returns `true` if the label matches, or `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * import { hasLabel } from '@limetech/lime-web-components';
+ *
+ * const properties = [
+ *     { label: 'name', type: 'string' },
+ *     { label: 'email', type: 'string' },
+ * ];
+ *
+ * const emailProperty = properties.find(hasLabel('email'));
+ * console.log(emailProperty); // { label: 'email', type: 'string' }
+ * ```
+ *
+ * @public
+ * @group Lime types
+ */
+export declare const hasLabel: (label: string) => (object?: LimeType | LimeProperty) => boolean;
+//# sourceMappingURL=has-label.d.ts.map

package/dist/limetype/has-label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-label.d.ts","sourceRoot":"","sources":["../../src/limetype/has-label.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,UACT,MAAM,eAAe,QAAQ,GAAG,YAAY,YAEnD,CAAC"}

package/dist/limetype/has-label.js

@@ -0,0 +1,29 @@
+/**
+ * Creates a function to check if a given object has a specific label.
+ *
+ * The returned function takes an object (a `LimeType` or `LimeProperty`) and
+ * checks whether it contains the specified label. This function is typically
+ * used as a callback for array methods like `.find` or `.filter`.
+ *
+ * @param label - The label to check for.
+ * @returns A function that takes an optional object and returns `true` if the label matches, or `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * import { hasLabel } from '@limetech/lime-web-components';
+ *
+ * const properties = [
+ *     { label: 'name', type: 'string' },
+ *     { label: 'email', type: 'string' },
+ * ];
+ *
+ * const emailProperty = properties.find(hasLabel('email'));
+ * console.log(emailProperty); // { label: 'email', type: 'string' }
+ * ```
+ *
+ * @public
+ * @group Lime types
+ */
+export const hasLabel = (label) => (object) => {
+    return (object === null || object === void 0 ? void 0 : object.label) === label;
+};

package/dist/limetype/has-label.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=has-label.spec.d.ts.map

package/dist/limetype/has-label.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-label.spec.d.ts","sourceRoot":"","sources":["../../src/limetype/has-label.spec.ts"],"names":[],"mappings":""}

package/dist/limetype/has-label.spec.js

@@ -0,0 +1,31 @@
+import { person } from '../testing/limetypes/person';
+import { hasLabel } from './has-label';
+describe('hasLabel', () => {
+    it('returns true if the object has the specified label', () => {
+        const checkLabel = hasLabel('primaryemailaddress');
+        expect(checkLabel(person.properties.email)).toBe(true);
+    });
+    it('returns false if the object does not have the specified label', () => {
+        const checkLabel = hasLabel('firstname');
+        expect(checkLabel(person.properties.email)).toBe(false);
+    });
+    it('returns false if the object is undefined', () => {
+        const checkLabel = hasLabel('firstname');
+        expect(checkLabel(undefined)).toBe(false);
+    });
+    describe('edge cases', () => {
+        it('returns false if the object has no label property', () => {
+            const obj = { type: 'string' };
+            const checkLabel = hasLabel('firstname');
+            expect(checkLabel(obj)).toBe(false);
+        });
+        // At the moment, if both the label and the search string are empty
+        // strings, the function will return true.
+        // That's probably a mistake? /Ads
+        it.skip('returns false if the label is an empty string', () => {
+            const obj = { label: '', type: 'string' };
+            const checkLabel = hasLabel('');
+            expect(checkLabel(obj)).toBe(false);
+        });
+    });
+});

package/dist/limetype/index.d.ts

@@ -4,4 +4,9 @@ export * from './property';
 export * from './repository';
 export * from './types';
 export * from './decorator';
+export * from './find-limetype-by-label';
+export * from './get-properties-by-type';
+export * from './get-property-by-label';
+export * from './get-property-by-name';
+export * from './has-label';
 //# sourceMappingURL=index.d.ts.map

package/dist/limetype/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/limetype/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/limetype/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC"}

package/dist/limetype/index.js

@@ -4,3 +4,8 @@ export * from './property';
 export * from './repository';
 export * from './types';
 export * from './decorator';
+export * from './find-limetype-by-label';
+export * from './get-properties-by-type';
+export * from './get-property-by-label';
+export * from './get-property-by-name';
+export * from './has-label';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/lime-web-components",
-  "version": "5.39.0",
+  "version": "5.40.0",
   "description": "Lime Web Components",
   "author": "Lime Technologies",
   "license": "Apache-2.0",