@dbmx/toasts 0.0.47 → 0.0.49

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

@@ -0,0 +1,554 @@
+'use strict';
+
+var index_esm = require('../../semver/dist/index.esm.cjs');
+var dependencyResolver = require('./dependencyResolver.cjs');
+var sdmx = require('./types/sdmx.cjs');
+var artefacts = require('./types/artefacts.cjs');
+var prop = require('./node_modules/ramda/es/prop.cjs');
+var pick = require('./node_modules/ramda/es/pick.cjs');
+
+/**
+ * @typedef Ref
+ * @property {string} - agencyID
+ * @property {string} - id
+ * @property {string} - semver version
+ * @property {string} - resourceType
+ */
+
+/**
+ * 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
+ *
+ * @function SDMXTypes
+ * @tag core
+ * @tag types
+ *
+ */
+const SDMXTypes = [
+  sdmx.Item({
+    name: 'agency',
+    packageName: 'base',
+    className: 'Agency',
+    schemeName: 'agencyscheme',
+  }),
+  sdmx.Artefact({
+    structureName: 'agencySchemes',
+    name: 'agencyscheme',
+    packageName: 'base',
+    className: 'AgencyScheme',
+  }),
+  sdmx.SDMX({
+    name: 'dataConsumer',
+    packageName: 'base',
+    className: 'DataConsumer',
+  }),
+  sdmx.SDMX({
+    name: 'dataConsumerScheme',
+    packageName: 'base',
+    className: 'DataConsumerScheme',
+  }),
+  sdmx.Item({
+    name: 'dataProvider',
+    packageName: 'base',
+    className: 'DataProvider',
+    schemeName: 'dataproviderscheme',
+  }),
+  sdmx.SDMX({
+    name: 'metadataProvider',
+    packageName: 'base',
+    className: 'MetadataProvider',
+  }),
+  sdmx.SDMX({
+    name: 'metadataProviderScheme',
+    packageName: 'base',
+    className: 'MetadataProviderScheme',
+  }),
+  sdmx.SDMX({
+    name: 'organisationUnit',
+    packageName: 'base',
+    className: 'OrganisationUnit',
+  }),
+  sdmx.SDMX({
+    name: 'organisationUnitScheme',
+    packageName: 'base',
+    className: 'OrganisationUnitScheme',
+  }),
+  sdmx.SDMX({
+    name: 'attributeDescriptor',
+    packageName: 'datastructure',
+    className: 'AttributeDescriptor',
+  }),
+  sdmx.Component({
+    name: 'dataAttribute',
+    packageName: 'datastructure',
+    className: 'DataAttribute',
+  }),
+  sdmx.Component({
+    name: 'dimension',
+    packageName: 'datastructure',
+    className: 'Dimension',
+  }),
+  sdmx.SDMX({
+    name: 'dimensionDescriptor',
+    packageName: 'datastructure',
+    className: 'DimensionDescriptor',
+  }),
+  sdmx.Component({
+    name: 'primaryMeasure',
+    packageName: 'datastructure',
+    className: 'PrimaryMeasure',
+    version: 2,
+  }),
+  sdmx.SDMX({
+    name: 'groupDimensionDescriptor',
+    packageName: 'datastructure',
+    className: 'GroupDimensionDescriptor',
+  }),
+  sdmx.Component({
+    name: 'measure',
+    packageName: 'datastructure',
+    className: 'Measure',
+  }),
+  sdmx.SDMX({
+    name: 'measureDescriptor',
+    packageName: 'datastructure',
+    className: 'MeasureDescriptor',
+  }),
+  sdmx.Component({
+    name: 'timeDimension',
+    packageName: 'datastructure',
+    className: 'TimeDimension',
+  }),
+  sdmx.Component({
+    name: 'metadataAttribute',
+    packageName: 'metadatastructure',
+    className: 'MetadataAttribute',
+  }),
+  sdmx.SDMX({
+    name: 'metadataAttributeDescriptor',
+    packageName: 'metadatastructure',
+    className: 'MetadataAttributeDescriptor',
+  }),
+  sdmx.SDMX({
+    name: 'metadataStructure',
+    packageName: 'metadatastructure',
+    className: 'MetadataStructure',
+  }),
+  sdmx.SDMX({
+    name: 'metadataflow',
+    packageName: 'metadatastructure',
+    className: 'Metadataflow',
+  }),
+  sdmx.SDMX({
+    name: 'metadataSet',
+    packageName: 'metadatastructure',
+    className: 'MetadataSet',
+  }),
+  sdmx.SDMX({
+    name: 'Process',
+    packageName: 'process',
+    className: 'Process',
+  }),
+  sdmx.SDMX({
+    name: 'processStep',
+    packageName: 'process',
+    className: 'ProcessStep',
+  }),
+  sdmx.SDMX({
+    name: 'transition',
+    packageName: 'process',
+    className: 'Transition',
+  }),
+  sdmx.Artefact({
+    structureName: 'metadataConstraints',
+    name: 'metadataConstraint',
+    packageName: 'registry',
+    className: 'MetadataConstraint',
+  }),
+  sdmx.SDMX({
+    name: 'metadataProvisionAgreement',
+    packageName: 'registry',
+    className: 'MetadataProvisionAgreement',
+  }),
+  sdmx.SDMX({
+    name: 'subscription',
+    packageName: 'registry',
+    className: 'Subscription',
+  }),
+  sdmx.SDMX({
+    name: 'categorySchemeMap',
+    packageName: 'structuremapping',
+    className: 'CategorySchemeMap',
+  }),
+  sdmx.SDMX({
+    name: 'conceptSchemeMap',
+    packageName: 'structuremapping',
+    className: 'ConceptSchemeMap',
+  }),
+  sdmx.SDMX({
+    name: 'organisationSchemeMap',
+    packageName: 'structuremapping',
+    className: 'OrganisationSchemeMap',
+  }),
+  sdmx.SDMX({
+    name: 'reportingTaxonomyMap',
+    packageName: 'structuremapping',
+    className: 'ReportingTaxonomyMap',
+  }),
+  sdmx.SDMX({
+    name: 'representationMap',
+    packageName: 'structuremapping',
+    className: 'RepresentationMap',
+  }),
+  sdmx.SDMX({
+    name: 'structureMap',
+    packageName: 'structuremapping',
+    className: 'StructureMap',
+  }),
+  sdmx.Item({
+    name: 'category',
+    packageName: 'categoryscheme',
+    className: 'Category',
+  }),
+  sdmx.SDMX({
+    name: 'reportingCategory',
+    packageName: 'categoryscheme',
+    className: 'ReportingCategory',
+  }),
+  sdmx.SDMX({
+    name: 'reportingTaxonomy',
+    packageName: 'categoryscheme',
+    className: 'ReportingTaxonomy',
+  }),
+  sdmx.Item({
+    name: 'concept',
+    packageName: 'conceptscheme',
+    className: 'Concept',
+  }),
+  sdmx.Item({
+    name: 'code',
+    packageName: 'codelist',
+    className: 'Code',
+  }),
+  sdmx.SDMX({
+    name: 'hierarchicalCode',
+    packageName: 'codelist',
+    className: 'HierarchicalCode',
+  }),
+  sdmx.SDMX({
+    name: 'hierarchy',
+    packageName: 'codelist',
+    className: 'Hierarchy',
+  }),
+  sdmx.SDMX({
+    name: 'hierarchyAssociation',
+    packageName: 'codelist',
+    className: 'HierarchyAssociation',
+  }),
+  sdmx.SDMX({
+    name: 'level',
+    packageName: 'codelist',
+    className: 'Level',
+  }),
+  sdmx.SDMX({
+    name: 'valueList',
+    packageName: 'codelist',
+    className: 'ValueList',
+  }),
+  sdmx.SDMX({
+    name: 'customType',
+    packageName: 'transformation',
+    className: 'CustomType',
+  }),
+  sdmx.SDMX({
+    name: 'customTypeScheme',
+    packageName: 'transformation',
+    className: 'CustomTypeScheme',
+  }),
+  sdmx.SDMX({
+    name: 'namePersonalisation',
+    packageName: 'transformation',
+    className: 'NamePersonalisation',
+  }),
+  sdmx.SDMX({
+    name: 'namePersonalisationScheme',
+    packageName: 'transformation',
+    className: 'NamePersonalisationScheme',
+  }),
+  sdmx.SDMX({
+    name: 'ruleset',
+    packageName: 'transformation',
+    className: 'Ruleset',
+  }),
+  sdmx.SDMX({
+    name: 'rulesetScheme',
+    packageName: 'transformation',
+    className: 'RulesetScheme',
+  }),
+  sdmx.SDMX({
+    name: 'transformation',
+    packageName: 'transformation',
+    className: 'Transformation',
+  }),
+  sdmx.SDMX({
+    name: 'transformationScheme',
+    packageName: 'transformation',
+    className: 'TransformationScheme',
+  }),
+  sdmx.SDMX({
+    name: 'userDefinedOperator',
+    packageName: 'transformation',
+    className: 'UserDefinedOperator',
+  }),
+  sdmx.SDMX({
+    name: 'userDefinedOperatorScheme',
+    packageName: 'transformation',
+    className: 'UserDefinedOperatorScheme',
+  }),
+  sdmx.SDMX({
+    name: 'vtlCodelistMapping',
+    packageName: 'transformation',
+    className: 'VtlCodelistMapping',
+  }),
+  sdmx.SDMX({
+    name: 'vtlConceptMapping',
+    packageName: 'transformation',
+    className: 'VtlConceptMapping',
+  }),
+  sdmx.SDMX({
+    name: 'vtlDataflowMapping',
+    packageName: 'transformation',
+    className: 'VtlDataflowMapping',
+  }),
+  sdmx.SDMX({
+    name: 'vtlMappingScheme',
+    packageName: 'transformation',
+    className: 'VtlMappingScheme',
+  }),
+  ...artefacts.Artefacts,
+];
+
+/*
+ * Object to get an artefact description from its structure name
+ *
+ * @function STRUCTURE_NAMES
+ * @tag artefact
+ * @tag core
+ */
+
+SDMXTypes.reduce((acc, artefact) => {
+  acc[artefact.structureName] = artefact;
+  return acc
+}, {});
+
+/*
+ * Object to get an artefact description from its class name
+ *
+ * @function CLASSES
+ * @tag artefact
+ * @tag core
+ */
+
+SDMXTypes.reduce((acc, artefact) => {
+  acc[artefact.className] = artefact;
+  return acc
+}, {});
+
+/*
+ * Object to get an artefact description from its name
+ *
+ * @function RESOURCES
+ * @constant
+ * @tag artefact
+ * @tag core
+ */
+
+SDMXTypes.reduce((acc, artefact) => {
+  acc[artefact.name] = artefact.name;
+  return acc
+}, {});
+
+const hResourceTypes = SDMXTypes.reduce((acc, artefact) => {
+  acc[artefact.name] = artefact;
+  return acc
+}, {});
+
+const urnType = type => `sdmx.infomodel.${type.packageName || type.name}.${type.className}`;
+
+const hArtefactUrnTypes = SDMXTypes.reduce((acc, artefact) => {
+  acc[urnType(artefact)] = artefact;
+  return acc
+}, {});
+
+/**
+ * Returns artefact description from its name
+ *
+ * @function getArtefactByType
+ * @tag artefact
+ * @tag core
+ * @return AttributeDescriptor
+ *
+ * @example
+ *    getArtefactByType('dataflow') //=> ArtefactDescription
+ */
+
+const getArtefactByType = type => hResourceTypes[type];
+
+/**
+ * Returns artefact description
+ *
+ * @function getArtefactByUrnType
+ * @tag artefact
+ * @tag core
+ * @param {string} - packageName
+ * @param {string} - className
+ * @return {ArtefactDescription}
+ *
+ * @example
+ *    getArtefactByType('dataflow') //=> ArtefactDescription
+ */
+
+const getArtefactByUrnType = (packageName, className) => hArtefactUrnTypes[urnType({ packageName, className })];
+// const parseURN = urn => urn.match(/^urn:sdmx:org\.sdmx\.infomodel\.(\w+)\.(\w+)=(.+):(.+)\((.+)\)(?:\.([\w.-]+))?/)
+const parseURN = urn => urn.match(/^urn:sdmx:org\.sdmx\.infomodel\.(\w+)\.(\w+)=(.+):(.+)\((.+)\)(?:\.(.+))?/);
+/**
+ * Returns full ref from URN
+ *
+ * @function urn2FullRef
+ * @tag core
+ * @tag URN
+ * @param {string} - urn
+ * @return  {FullRef} -
+ *
+ * @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')
+ */
+const urn2FullRef = urn => {
+  if (!urn) return
+  const res = parseURN(urn);
+  if (!res) throw new Error(`Malformed URN: ${urn}`)
+  const [_, packageName, className, agencyID, id, version, itemId] = res; // eslint-disable-line
+  const artefact = getArtefactByUrnType(packageName, className);
+  if (!artefact) throw new Error(`Unknow artefact for URN: ${urn}`)
+  const resource = {
+    resourceType: artefact.name,
+    agencyID,
+    id,
+    version,
+  };
+  if (artefact.isItem && !itemId) throw new Error(`Inconsistent urn for an item: ${urn}`)
+  if (itemId) resource.itemId = itemId;
+  return resource
+};
+
+/**
+ * Returns a Ref from a resource
+ *
+ * @function getRef
+ * @tag core
+ * @tag resource
+ * @param {object} - input structure
+ * @return {Ref} - pick(['agencyID', 'id', 'version'], resource)
+ *
+ */
+
+const getRef = (resource = {}, resourceType) => {
+  const localResourceType = resourceType ?? resource.resourceType;
+  const res = pick(['id', 'agencyID', 'version'], resource);
+  if (localResourceType) res.resourceType = localResourceType;
+  return res
+};
+
+/**
+ * Returns an identifier for an artefact based on { agencyID, id, version }
+ *
+ * @example
+ *
+ *   const resource1 = { agencyID: 'AG', id: 'ID1', version: '1.0.3'}
+ *   const resource2 = { agencyID: 'AG', id: 'ID2', version: '1.0'}
+ *   expect(ID(resource1) !== ID(resource2)).toBeTruthy()
+ */
+
+const ID = ({ agencyID, id, version, itemId } = {}) => {
+  if (!agencyID) throw new Error('agencyID cannot be null')
+  if (!id) throw new Error('id cannot be null')
+  return itemId ? `${agencyID}:${id}:${version}:${itemId}` : `${agencyID}:${id}:${version}`
+};
+
+/**
+ * Gets structure.data[resourceType]
+ *
+ * @function getResourcesFromStructure
+ * @tag core
+ * @param {object} - SDMX structure
+ * @param {type} - resourceType | structureName
+ * @return {object} - structure.data[resourceType]
+ *
+ */
+
+const getResourcesFromStructure = ({ data = {} } = {}, type) =>
+  data[type] ?? data[getArtefactByType(type)?.structureName] ?? [];
+
+/**
+ * Resolved resource from structure
+ *
+ * @function resolveResourceFromStructure
+ * @tag core
+ * @param {object} - SDMX structure
+ * @param {object} - { version } of the source dependency
+ * @param {Ref} - Ref of the target dependency
+ * @return {object} - resolved resource
+ *
+ * @example
+ *
+ * const structure = {
+ *     data: {
+ *       categorySchemes: [artefact],
+ *     },
+ *   }
+ *   const res = resolveResourceFromStructure(
+ *     structure,
+ *     { version: '1.0.0' },
+ *     { ...getRef(artefact, 'categoryscheme'), version: '1+.0.0' },
+ *   )
+ *   expect(res).toEqual(artefact)
+ *
+ */
+const resolveResourceFromStructure = ({ data = {} } = {}, source, ref = {}, { noError } = {}) => {
+  const resources = getResourcesFromStructure({ data }, ref.resourceType);
+  try {
+    const res = dependencyResolver.resolveDependency(resources, source, getRef(ref));
+    return res
+  } catch (err) {
+    if (err instanceof index_esm.SemVerError) {
+      if (noError) return
+      throw err
+    } else throw err
+  }
+};
+
+/**
+ * Returns true if resource is external
+ *
+ * @function isExternal
+ * @tag links
+ * @tag core
+ * @param {Artefact} - resource
+ *
+ */
+
+prop('isExternalReference');
+
+exports.ID = ID;
+exports.SDMXTypes = SDMXTypes;
+exports.getArtefactByType = getArtefactByType;
+exports.getArtefactByUrnType = getArtefactByUrnType;
+exports.getRef = getRef;
+exports.getResourcesFromStructure = getResourcesFromStructure;
+exports.resolveResourceFromStructure = resolveResourceFromStructure;
+exports.urn2FullRef = urn2FullRef;

package/cjs/node_modules/@dbmx/sdmx/esm/datastructures.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var core = require('./core.cjs');
+
+/**
+ * Returns components defined in dataStructure
+ *
+ * @function getComponents
+ * @tag datastructures
+ * @param {object} - datastructure
+ * @return {array} - array of component
+ *
+ */
+
+const ComponentTypes = {
+  dimension: 'dimension',
+  timeDimension: 'timeDimension',
+  measure: 'measure',
+  attribute: 'attribute',
+};
+
+const getCompId = comp => {
+  if (comp.id) return comp
+  const ref = core.urn2FullRef(comp.conceptIdentity);
+  comp.id = ref.itemId;
+  return comp
+};
+
+const getTimeDimension = dataStructure => {
+  const timeDimension =
+    dataStructure?.dataStructureComponents?.dimensionList?.timeDimension ||
+    dataStructure?.dataStructureComponents?.dimensionList?.timeDimensions?.[0];
+  if (!timeDimension) return
+  return { ...getCompId(timeDimension), type: ComponentTypes.timeDimension }
+};
+
+const getDimensions = dataStructure => {
+  let res = [];
+  const dimensions = dataStructure?.dataStructureComponents?.dimensionList?.dimensions;
+  if (dimensions?.length)
+    res = [...res, ...dimensions.map(comp => ({ ...getCompId(comp), type: ComponentTypes.dimension }))];
+  const timeDimension = getTimeDimension(dataStructure);
+  if (timeDimension) res = [...res, timeDimension];
+  return res
+};
+
+const getAttributes = dataStructure => {
+  const attributes =
+    dataStructure?.dataStructureComponents?.attributeList?.attributes ??
+    dataStructure?.metadataStructureComponents?.metadataAttributeList?.metadataAttributes;
+  if (!attributes?.length) return []
+  return attributes.map(comp => ({ ...getCompId(comp), type: ComponentTypes.attribute }))
+};
+
+const getMeasures = dataStructure => {
+  const measures =
+    dataStructure?.dataStructureComponents?.measureList?.measures ??
+    (dataStructure?.dataStructureComponents?.measureList?.primaryMeasure
+      ? [dataStructure.dataStructureComponents.measureList.primaryMeasure]
+      : []);
+  if (!measures?.length) return []
+  return measures.map(comp => ({ ...getCompId(comp), type: ComponentTypes.measure }))
+};
+
+const getComponents = dataStructure => {
+  return [...getDimensions(dataStructure), ...getMeasures(dataStructure), ...getAttributes(dataStructure)]
+};
+
+exports.getAttributes = getAttributes;
+exports.getComponents = getComponents;
+exports.getDimensions = getDimensions;
+exports.getMeasures = getMeasures;
+exports.getTimeDimension = getTimeDimension;

package/cjs/node_modules/@dbmx/sdmx/esm/dependencyResolver.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+var index_esm = require('../../semver/dist/index.esm.cjs');
+
+// TODO: remove resourceType from comparaison
+const matchRefVersionLess = (ref, resource) =>
+  ((ref.resourceType && resource.resourceType && ref.resourceType === resource.resourceType) ||
+    !ref.resourceType ||
+    !resource.resourceType) &&
+  ref.id === resource.id &&
+  ref.agencyID === resource.agencyID;
+
+const getOne = (ref, range, resources) => {
+  for (const resource of resources) {
+    if (matchRefVersionLess(ref, resource) && range.test(resource.version)) return resource
+  }
+};
+
+const getLatest = (ref, range, resources) => {
+  let res = [];
+  if (resources.length === 1 && range.raw === '~') return resources[0]
+  for (const resource of resources) {
+    if (!matchRefVersionLess(ref, resource)) continue
+    const semver = index_esm.SemVer(resource.version);
+    if (semver.isNonVersioned()) continue
+    if (range.test(semver)) {
+      if (!res[0]) res = [resource, semver];
+      else if (semver.compare(res[1]) === 1) res = [resource, semver];
+    }
+  }
+  return res[0]
+};
+
+/**
+ * Returns an external resource from the input
+ *
+ * @function resolveDependency
+ * @tag dependency
+ * @param {array} - all possible resources
+ * @param {object} - source of the dependency
+ * @param {object} - target version
+ *
+ * @example
+ *
+ *   const resources = [
+ *      { agencyID: 'A', id: 'ID1', version: '1.0.0' },
+ *      { agencyID: 'A', id: 'ID2', version: '1.0.1' },
+ *      { agencyID: 'A', id: 'ID3', version: '1.1.1' },
+ *   ]
+ *   const ref = resolveDependency(resources, { version: 1.0.0 }, { resourceType, agencyID, id, version: '1.1+.0' }
+ *   expect(ref.id}.toEqual('ID3')
+ */
+
+const resolveDependency = (resources, source, ref, { noError } = {}) => {
+  try {
+    const range = index_esm.Dependency(source, ref.version).range;
+    if (range.type === index_esm.RANGE_TYPE.LATEST) return getLatest(ref, range, resources)
+    return getOne(ref, range, resources)
+  } catch (err) {
+    if (noError) return
+    throw err
+  }
+};
+
+exports.resolveDependency = resolveDependency;