@dbmx/toasts 0.0.56 → 0.0.58

package/cjs/node_modules/@dbmx/sdmx/cjs/core.cjs

@@ -35,19 +35,20 @@ function requireCore () {
 
 	/**
 	 * @typedef Ref
-	 * @property {string} - agencyID
-	 * @property {string} - id
-	 * @property {string} - semver version
-	 * @property {string} - resourceType
+	 * @property {string} - Agency ID of the artefact
+	 * @property {string} - ID of the artefact
+	 * @property {string} - SemVer version of the artefact
+	 * @property {string} - Resource Type
 	 */
 
 	/**
 	 * Array of SDMX Artefact to get artefact description
-	 * @property {string} name - name use in rest API
-	 * @property {package} packageName - package's name use to build urn
-	 * @property {package} className - class's name use to build urn
-	 * @property {package} structureName - name use in structure messages
+	 * @property {string} - Name used in the REST API
+	 * @property {string} - Package's name used to build the URN
+	 * @property {string} - Class's name used to build the URN
+	 * @property {string} - Name used in structure messages
 	 *
+	 * @constant
 	 * @function SDMXTypes
 	 * @tag core
 	 * @tag types
@@ -137,14 +138,6 @@ function requireCore () {
 	  name: 'metadataAttributeDescriptor',
 	  packageName: 'metadatastructure',
 	  className: 'MetadataAttributeDescriptor'
-	}), sdmx$1.SDMX({
-	  name: 'metadataStructure',
-	  packageName: 'metadatastructure',
-	  className: 'MetadataStructure'
-	}), sdmx$1.SDMX({
-	  name: 'metadataflow',
-	  packageName: 'metadatastructure',
-	  className: 'Metadataflow'
 	}), sdmx$1.SDMX({
 	  name: 'metadataSet',
 	  packageName: 'metadatastructure',
@@ -218,10 +211,6 @@ function requireCore () {
 	  name: 'code',
 	  packageName: 'codelist',
 	  className: 'Code'
-	}), sdmx$1.SDMX({
-	  name: 'hierarchicalCode',
-	  packageName: 'codelist',
-	  className: 'HierarchicalCode'
 	}), sdmx$1.SDMX({
 	  name: 'hierarchy',
 	  packageName: 'codelist',
@@ -296,9 +285,10 @@ function requireCore () {
 	  className: 'VtlMappingScheme'
 	}), ...artefacts$1.Artefacts];
 
-	/*
+	/**
 	 * Object to get an artefact description from its structure name
 	 *
+	 * @constant
 	 * @function STRUCTURE_NAMES
 	 * @tag artefact
 	 * @tag core
@@ -309,9 +299,10 @@ function requireCore () {
 	  return acc;
 	}, {});
 
-	/*
+	/**
 	 * Object to get an artefact description from its class name
 	 *
+	 * @constant
 	 * @function CLASSES
 	 * @tag artefact
 	 * @tag core
@@ -322,11 +313,11 @@ function requireCore () {
 	  return acc;
 	}, {});
 
-	/*
+	/**
 	 * Object to get an artefact description from its name
 	 *
-	 * @function RESOURCES
 	 * @constant
+	 * @function RESOURCES
 	 * @tag artefact
 	 * @tag core
 	 */
@@ -351,7 +342,8 @@ function requireCore () {
 	 * @function getArtefactByType
 	 * @tag artefact
 	 * @tag core
-	 * @return AttributeDescriptor
+	 * @param {string} - Artefact type
+	 * @return {AttributeDescriptor}
 	 *
 	 * @example
 	 *    getArtefactByType('dataflow') //=> ArtefactDescription
@@ -362,13 +354,13 @@ function requireCore () {
 	const getArtefactByStructureName = name => STRUCTURE_NAMES[name];
 
 	/**
-	 * Returns artefact description
+	 * Returns artefact description from its URN type
 	 *
 	 * @function getArtefactByUrnType
 	 * @tag artefact
 	 * @tag core
-	 * @param {string} - packageName
-	 * @param {string} - className
+	 * @param {string} - Package name
+	 * @param {string} - Class name
 	 * @return {ArtefactDescription}
 	 *
 	 * @example
@@ -381,35 +373,35 @@ function requireCore () {
 	})];
 
 	/**
-	 * Returns true if param is a valid structure name
+	 * Checks if the parameter is a valid artefact name
 	 *
 	 * @function isValidArtefactName
 	 * @tag artefact
 	 * @tag core
-	 * @param {string} - name
-	 * @return {Boolean}
+	 * @param {string} - Artefact name to validate
+	 * @return {Boolean} - Returns true if the parameter is a valid artefact name, otherwise false
 	 */
 	const isValidArtefactName = name => STRUCTURE_NAMES[name];
 
 	/**
-	 * Returns true if param is an structure name
+	 * Checks if the parameter is a valid structure name
 	 *
 	 * @function isValidStructureName
 	 * @tag artefact
 	 * @tag core
-	 * @param {string} - name
-	 * @return {Boolean}
+	 * @param {string} - Structure name to validate
+	 * @return {Boolean} - Returns true if the parameter is a valid structure name, otherwise false
 	 */
 	const isValidStructureName = name => STRUCTURE_NAMES[name];
 
 	/**
-	 * Returns true if param is an artefact name
+	 * Checks if the parameter is a valid resourceType
 	 *
 	 * @function isValidResourceType
 	 * @tag artefact
 	 * @tag core
-	 * @param {string} - name
-	 * @return {Boolean}
+	 * @param {string} - Resource type to validate
+	 * @return {Boolean} - Returns true if the parameter is a valid resourceType, otherwise false
 	 */
 	const isValidResourceType = type => hResourceTypes[type];
 	const SDMXPrefix = 'urn:sdmx:org';
@@ -426,13 +418,13 @@ function requireCore () {
 	 */
 
 	/**
-	 * Returns URN  from full ref
+	 * Returns URN from full reference
 	 *
 	 * @function makeUrn
 	 * @tag core
 	 * @tag URN
-	 * @param {FullRef}
-	 * @return {string} - an `urn`
+	 * @param {FullRef} - Full reference
+	 * @return {string} - URN
 	 *
 	 * @example
 	 *
@@ -468,13 +460,13 @@ function requireCore () {
 	  return `${base}.${localItemID}`;
 	};
 	/**
-	 * Returns full ref from URN
+	 * Returns full reference from URN
 	 *
 	 * @function urn2FullRef
 	 * @tag core
 	 * @tag URN
-	 * @param {string} - urn
-	 * @return  {FullRef} -
+	 * @param {string} - URN
+	 * @return  {FullRef} - Full reference
 	 *
 	 * @example
 	 *
@@ -502,18 +494,26 @@ function requireCore () {
 	const getDescription = (locale, obj = {}) => obj.descriptions?.[locale];
 
 	/**
-	 * Returns Ref from URN
+	 * Returns reference from URN
 	 *
 	 * @function urn2Ref
 	 * @tag core
 	 * @tag URN
-	 * @param {string} - urn
-	 * @return  {Ref} -
+	 * @param {string} - URN
+	 * @return  {Ref} - Reference
 	 *
 	 */
 
 	const urn2Ref = urn => dissoc$1('itemId', urn2FullRef(urn));
 
+	/**
+	 * @typedef SDMXVersion
+	 * @property {string} - extension
+	 * @property {number} - major
+	 * @property {number} - minor
+	 * @property {number} - patch
+	 * @property {string} - version (major.minor.patch)
+	 */
 	/**
 	 * Returns version of a meta object (structure or data message)
 	 *
@@ -521,35 +521,60 @@ function requireCore () {
 	 * @tag core
 	 * @param {object} - a `meta` object from a Structure or Data SDMX message
 	 * @param {object=} - options, allow to define default version to return when previous prams to not contains a `meta` prop
-	 * @return  {string} - ['1', '2']
+	 * @return  {SDMXVersion}
 	 *
 	 * @example
 	 *
-	 *   const urn = 'urn:sdmx:org.sdmx.infomodel.codelist.Codelist=SDMX:CL_AGE(1.0).YOT4'
-	 *   urn2FullRef(urn) //=> { resourceType = 'codelist', agencyID: 'SDMX", id: 'CL_AGE', version; '1.0', itemId: 'YOT4')
+	 *   getSdmxVersion(meta) // => { major: '1', minor: '0', patch: '0', version: '1.0.0' )
 	 */
 	const getSdmxVersion = ({
 	  schema
 	} = {}, {
-	  defaultVersion = '2'
+	  defaultVersion = '2.0.0'
 	} = {}) => {
-	  if (!schema) return defaultVersion;
+	  if (!schema) return semver.SemVer(defaultVersion);
 	  const res = schema.match(/\/schemas\/(.*)\//);
-	  if (!res) return defaultVersion;
 	  try {
-	    return semver.SemVer(res[1]).major === 2 ? '2' : '1';
+	    if (!res) return semver.SemVer(defaultVersion);
+	    return semver.SemVer(res[1]);
 	  } catch (err) {
-	    return defaultVersion;
+	    return semver.SemVer(defaultVersion);
 	  }
 	};
 
 	/**
-	 * Returns a Ref from a resource
+	 * Returns the major version of a meta object (structure or data message)
+	 *
+	 * @function getMajorSdmxVersion
+	 * @tag core
+	 * @param {object} - a `meta` object from a Structure or Data SDMX message
+	 * @param {object=} - options, allow to define default version to return when previous prams to not contains a `meta` prop
+	 * @return  {string} - Major version
+	 *
+	 * @example
+	 *
+	 *   getMajorSdmxVersion(meta) // => 1
+	 */
+	const getMajorSdmxVersion = ({
+	  schema
+	} = {}, {
+	  defaultVersion = '2.0.0'
+	} = {}) => {
+	  return getSdmxVersion({
+	    schema
+	  }, {
+	    defaultVersion
+	  }).major;
+	};
+
+	/**
+	 * Returns a reference from a resource
 	 *
 	 * @function getRef
 	 * @tag core
 	 * @tag resource
-	 * @param {object} - input structure
+	 * @param {object} - Input structure
+	 * @param {string=} - Resource type
 	 * @return {Ref} - pick(['agencyID', 'id', 'version'], resource)
 	 *
 	 */
@@ -562,13 +587,14 @@ function requireCore () {
 	};
 
 	/**
-	 * Returns a FullRef from a resource
+	 * Returns a full reference from a resource
 	 *
 	 * @function getFullRef
 	 * @tag core
 	 * @tag resource
-	 * @param {object} - input structure
-	 * @return {FullRef}
+	 * @param {object} - Input structure
+	 * @param {string=} - Resource type
+	 * @return {FullRef} - Full reference
 	 *
 	 */
 
@@ -612,6 +638,9 @@ function requireCore () {
 	/**
 	 * Returns an identifier for an artefact based on { agencyID, id, version }
 	 *
+	 * @function ID
+	 * @tag core
+	 * @param {object} - Source input
 	 * @example
 	 *
 	 *   const resource1 = { agencyID: 'AG', id: 'ID1', version: '1.0.3'}
@@ -638,7 +667,7 @@ function requireCore () {
 	 * @function isPatternedVersion
 	 * @tag core
 	 * @tag version
-	 * @param {string} - version
+	 * @param {string} - Version
 	 *
 	 * @example
 	 *
@@ -722,7 +751,8 @@ function requireCore () {
 	 * @tag core
 	 * @param {object} - SDMX structure
 	 * @param {FullRef} - fullRef
-	 * @return {string} - resourceType
+	 * @param {string} - resourceType
+	 * @return {object} - resource
 	 *
 	 */
 
@@ -795,11 +825,33 @@ function requireCore () {
 	  return res;
 	};
 	const isUrlRegex = url => urlRegexp$1.test(url);
+
+	/**
+	 * Gets the latest minor version for a provided source version
+	 *
+	 * @function getLatestMinor
+	 * @tag core
+	 * @param {string} - Version
+	 * @return  {string} - Latest minor version
+	 * @example
+	 *
+	 *   getLatestMinor({ version: '1.0.0-draft' })
+	 */
 	const getLatestMinor = version => {
 	  const semver$1 = semver.SemVer(version);
 	  if (semver$1.patch === null) return `${semver$1.major}.${semver$1.minor}`;
 	  return `${semver$1.major}.${semver$1.minor}+.${semver$1.patch}`;
 	};
+
+	/**
+	 * Retrieves the data structure from an artefact based on the provided full reference
+	 * This function is particularly useful for obtaining the data structure associated with a specific artefact
+	 *
+	 * @function getDataStructureFromArtefact
+	 * @param {object} structure - SDMX structure object containing data
+	 * @param {FullRef} fullRef - Full reference of the artefact
+	 * @throws {Error} - Throws an error if the data structure cannot be retrieved
+	 */
 	const getDataStructureFromArtefact = (structure, fullRef) => {
 	  const target = getResourceFromStructure(structure, fullRef);
 	  if (!target) throw new Error(`Cannot get dataStructure for ${JSON.stringify(fullRef)}!`);
@@ -894,6 +946,15 @@ function requireCore () {
 	  if (!isExternalReference) return;
 	  return getLinkType('external', links)?.href;
 	};
+
+	/**
+	 * Retrieves the link of a specific type from a list of links
+	 *
+	 * @function getLinkType
+	 * @param {string} type - Link type to retrieve (e.g., 'external', 'self')
+	 * @param {Array} links - Aarray of link objects
+	 * @return {object|undefined} - Link object of the specified type, or undefined if not found
+	 */
 	const getLinkType = (type, links = []) => links.find(link => link.rel === type);
 	core.__exports.CLASSES = CLASSES;
 	core.__exports.ID = ID;
@@ -911,6 +972,7 @@ function requireCore () {
 	core.__exports.getItemArtefactByResourceType = getItemArtefactByResourceType;
 	core.__exports.getLatestMinor = getLatestMinor;
 	core.__exports.getLinkType = getLinkType;
+	core.__exports.getMajorSdmxVersion = getMajorSdmxVersion;
 	core.__exports.getName = getName;
 	core.__exports.getRef = getRef;
 	core.__exports.getResourceFromStructure = getResourceFromStructure;

package/cjs/node_modules/@dbmx/sdmx/cjs/data.cjs

@@ -1,51 +1,124 @@
 'use strict';
 
 var core = require('./core.cjs');
-var slice$1 = require('./node_modules/ramda/es/slice.cjs');
-var times$1 = require('./node_modules/ramda/es/times.cjs');
-var concat$1 = require('./node_modules/ramda/es/concat.cjs');
 var isNil$1 = require('./node_modules/ramda/es/isNil.cjs');
 
 core.__require();
-var slice = slice$1.slice_1;
-var times = times$1.times_1;
-var concat = concat$1.concat_1;
 var isNil = isNil$1.isNil_1;
-const fillSlice = (start, size, input = [], value = null) => {
-  const d1 = slice(start, size, input);
+
+/**
+ * Fills a slice of an array with a specified value
+ *
+ * @function fillSlice
+ * @param {number} - Starting index of the slice
+ * @param {number} - Size of the slice
+ * @param {Array} - Input array
+ * @param {*} - Value to fill the slice with
+ * @return {Array} - Filled slice
+ *
+ * @example
+ * const filledSlice = fillSlice(0, 3, ['a', 'b', 'c'], 'x');
+ */
+const fillSlice = (start, size = -1, input = [], value = null) => {
+  const d1 = input.slice(start, start + size);
   if (size - d1.length < 0) return d1;
-  const d2 = times(() => value, size - d1.length);
-  return concat(d1, d2);
+  const d2 = new Array(size - d1.length).fill(value);
+  return d1.concat(d2);
 };
-const getDefaultCompValue = comp => comp.default;
-const getdSetDimensions = structure => {
-  const dimensions = structure?.dimensions?.dataSet || [];
+
+// export const fillSlice = (start, size, input = [], value = null) => {
+//   const d1 = input.slice(start, size)
+//   if (size - d1.length < 0) return d1
+//   const d2 = times(() => value, size - d1.length)
+//   return d1.concat(d2)
+// }
+
+const getListedComponentValue = (component, value) => {
+  if (value === null) {
+    if (component.default) {
+      const dvalue = component.values.find(v => v?.id === component.default);
+      if (dvalue === -1) throw new Error(`Cannot get default value for component ${component.id}!`);
+      return dvalue;
+    }
+    return null;
+  } else {
+    const cvalue = component.values[value];
+    if (cvalue === undefined) throw new Error(`Cannot get value idx ${value} for component ${component.id}!`);
+    return cvalue;
+  }
+};
+const getComponentValue = (component, value) => {
+  if (!component.values) {
+    // not listed
+    if (value === null) return null;else return {
+      value
+    };
+  } else {
+    return getListedComponentValue(component, value);
+  }
+};
+const getObsValues = (components, values) => {
   const res = {};
-  for (const dimension of dimensions) {
-    if (!dimension.values) continue;
-    res[dimension.id] = dimension.values[0];
+  for (const [idx, value] of values.entries()) {
+    const component = components[idx];
+    if (!component) throw new Error(`Cannot get dataset component idx ${idx}!`);
+    const v = getComponentValue(component, value);
+    if (!isNil(v)) res[component.id] = getComponentValue(component, value);
   }
   return res;
 };
-const getdSetAttributes = structure => {
-  const attributes = structure?.attributes?.dataSet || [];
+
+/**
+ * Gets the dimensions of a dataset
+ *
+ * @function getdSetDimensions
+ * @param {object} - Structure object
+ * @return {object} - Dataset dimensions
+ *
+ */
+const getdSetDimensions = structure => {
+  const dimensions = structure?.dimensions?.dataSet ?? [];
   const res = {};
-  for (const attribute of attributes) {
-    if (!attribute.values) continue;
-    res[attribute.id] = attribute.values[0];
+  for (const dimension of dimensions) {
+    const v = getListedComponentValue(dimension, 0);
+    if (!isNil(v)) res[dimension.id] = v;
   }
   return res;
 };
-const unpackDimensions = key => key.split(':');
+
+/**
+ * Gets the attributes of a dataset
+ *
+ * @function getdSetAttributes
+ * @param {object} - Dataset object
+ * @param {object} - Structure object
+ * @return {object} - Dataset attributes
+ *
+ */
+const getdSetAttributes = (dataset, structure) => {
+  const attributes = structure?.attributes?.dataSet ?? [];
+  const values = fillSlice(0, attributes.length, dataset?.attributes ?? []);
+  return getObsValues(attributes, values);
+};
+const unpackDimensions = (key = '') => key.split(':');
+
+/**
+ * Gets the dimensions of an observation
+ *
+ * @function getObsDimensions
+ * @param {object} - Structure object
+ * @param {string} - Observation key
+ * @return {object} - Observation dimensions
+ *
+ */
 const getObsDimensions = (structure, key) => {
   const dimensions = structure?.dimensions?.observation || [];
   const res = {};
   for (const [idx, idxValue] of unpackDimensions(key).entries()) {
     const dimension = dimensions[idx];
     if (!dimension) throw new Error(`Cannot get dimension idx ${idx}!`);
-    const value = dimension.values[idxValue];
-    if (!value) throw new Error(`Cannot get value ${idxValue} for dimension ${dimension.id}!`);
-    res[dimension.id] = value;
+    const v = getComponentValue(dimension, idxValue);
+    if (!isNil(v)) res[dimension.id] = v;
   }
   return res;
 };
@@ -55,36 +128,23 @@ const getDataObsAttributes = (structure, values) => {
   const attributeValues = fillSlice(measures.length, attributes.length, values);
   return getObsAttributes(structure, attributeValues);
 };
+
+/**
+ * Gets the attributes of an observation.
+ *
+ * @function getObsAttributes
+ * @param {object} structure - Structure object
+ * @param {Array} values - Observation value
+ * @return {object} - Observation attributes
+ *
+ */
 const getObsAttributes = (structure, values) => {
   const attributes = structure?.attributes?.observation || [];
-  const res = {};
-  for (const [idx, idxValue] of values.entries()) {
-    const attribute = attributes[idx];
-    if (!attribute) throw new Error(`Cannot get attribute idx ${idx}!`);
-    if (attribute.values) {
-      if (idxValue === null) {
-        const defaultValue = getDefaultCompValue(attribute);
-        if (!isNil(defaultValue)) res[attribute.id] = {
-          value: defaultValue
-        };
-      } else {
-        const value = attribute.values[idxValue];
-        if (value !== null) {
-          if (!value) throw new Error(`Cannot get value ${idxValue} for attribute ${attribute.id}!`);
-          res[attribute.id] = value;
-        }
-      }
-    } else {
-      if (idxValue !== null) res[attribute.id] = {
-        value: idxValue
-      };
-    }
-  }
-  return res;
+  return getObsValues(attributes, values);
 };
-const getKeyAttributes = (structure, key) => {
+const getKeyAttributes = (dataset, structure, key) => {
   return {
-    ...getdSetAttributes(structure),
+    ...getdSetAttributes(dataset, structure),
     ...getDataObsAttributes(structure, key)
   };
 };
@@ -95,28 +155,61 @@ const getKeyMeasures = (structure, values) => {
 };
 const getMeasures = (structure, values) => {
   const measures = structure?.measures?.observation || [];
-  const res = {};
-  for (const [idx, idxValue] of values.entries()) {
-    const measure = measures[idx];
-    if (!measure) throw new Error(`Cannot get measure idx ${idx}!`);
-    if (idxValue === null) continue;else if (!measure.values) {
-      res[measure.id] = {
-        value: idxValue
-      };
-    } else {
-      const value = measure.values[idxValue];
-      if (!value) throw new Error(`Cannot get value ${idxValue} for measure ${measure.id}!`);
-      res[measure.id] = value;
-    }
-  }
-  return res;
+  return getObsValues(measures, values);
 };
+const getFullDimKey = (datasetStructure, dimKey) => `${'0:'.repeat(datasetStructure.dimensions?.dataSet?.length ?? 0)}${dimKey}`;
 const getDimensions = (structure, key) => {
   return {
     ...getdSetDimensions(structure),
     ...getObsDimensions(structure, key)
   };
 };
+
+/**
+ * Checks if an observation key matches a dimension group key.
+ *
+ * @function dimGroupKeyMatches
+ * @param {string} - Observation key
+ * @param {string} - DimensionGroup key
+ * @return {boolean} - True if the keys match, otherwise false
+ *
+ */
+const dimGroupKeyMatches = (obsKey, grpKey) => {
+  const obsValues = obsKey.split(':');
+  const grpValues = grpKey.split(':');
+  if (obsValues.length !== grpValues.length) throw new Error(`Inconsistent  dimensionGroupAttributes key ${grpKey}`);
+  for (const [idx, obsValue] of obsValues.entries()) {
+    const grpValue = grpValues[idx];
+    if (grpValue !== '' && grpValue !== '~' && obsValue !== grpValue) return false;
+  }
+  return true;
+};
+const getMatchedDimensionGroupAttributes = (structure, dataset, key) => {
+  let res = {};
+  const fullDimKey = getFullDimKey(structure, key);
+  const attributes = structure?.attributes?.dimensionGroup || [];
+  for (const grpKey in dataset.dimensionGroupAttributes || {}) {
+    if (dimGroupKeyMatches(fullDimKey, grpKey)) {
+      const values = fillSlice(0, attributes.length, dataset.dimensionGroupAttributes[grpKey]);
+      const dimAttrs = getObsValues(attributes, values);
+      for (const id in dimAttrs) {
+        if (dimAttrs[id] !== null) res[id] = dimAttrs[id];
+      }
+    }
+  }
+  return res;
+};
+
+/**
+ * Generates observations
+ *
+ * @function getObservations
+ * @param {object} dataStructure - Data structure object
+ * @param {object} - Options object
+ * @param {number} - Dataset index
+ * @yields {object} - Observations
+ *
+ */
 function* getObservations(dataStructure, {
   dSet = 0
 } = {}) {
@@ -130,7 +223,8 @@ function* getObservations(dataStructure, {
     const obs = {
       ...getDimensions(structure, key),
       ...getKeyMeasures(structure, observations[key]),
-      ...getKeyAttributes(structure, observations[key])
+      ...getKeyAttributes(dataSet, structure, observations[key]),
+      ...getMatchedDimensionGroupAttributes(structure, dataSet, key)
     };
     yield obs;
   }