jtlt 0.2.0 → 0.3.0

package/src/JSONJoiningTransformer.js

@@ -10,6 +10,43 @@ function _makeDatasetAttribute (n0) {
   return n0.charAt(0) + '-' + n0.charAt(1).toLowerCase();
 }
 
+/**
+ * @callback ObjectCallback
+ * @this {JSONJoiningTransformer}
+ * @param {Record<string, unknown>} obj
+ * @returns {void}
+ */
+/**
+ * @callback ArrayCallback
+ * @this {JSONJoiningTransformer}
+ * @param {any[]} arr
+ * @returns {void}
+ */
+/**
+ * @template [T = "json"]
+ * @callback SimpleCallback
+ * @this {T extends "json" ? JSONJoiningTransformer :
+ *   T extends "string" ? import('./StringJoiningTransformer.js').default
+ *   : import('./DOMJoiningTransformer.js').default}
+ * @returns {void}
+ */
+
+/**
+ * Attributes object for element() allowing standard string attributes
+ * plus special helpers: dataset (object) and $a (ordered attribute array).
+ * @typedef {Record<string, unknown> & {
+ *   dataset?: Record<string, string>,
+ *   $a?: Array<[string, string]>
+ * }} ElementAttributes
+ */
+
+/**
+ * @typedef {{
+ *   attsObj: Record<string, unknown>,
+ *   jmlChildren: unknown[]
+ * }} ElementInfo
+ */
+
 /**
  * JSON-based joining transformer for building JSON/JavaScript objects.
  *
@@ -17,27 +54,35 @@ function _makeDatasetAttribute (n0) {
  * append() will push to arrays or shallow-merge into objects; string/number/
  * boolean/null add primitives accordingly. It does not perform HTML escaping
  * or string serialization; it builds real JS values.
+ * @extends {AbstractJoiningTransformer<"json">}
  */
 class JSONJoiningTransformer extends AbstractJoiningTransformer {
   /**
-   * @param {any[]|object} [o] - Initial object or array
-   * @param {object} [cfg] - Configuration object
+   * @param {any[]|Record<string, unknown>} [o] - Initial object or array
+   * @param {import('./AbstractJoiningTransformer.js').
+   *   JSONJoiningTransformerConfig} [cfg] - Configuration object
    */
   constructor (o, cfg) {
     super(cfg);
-    /** @type {any[]|object} */
+    /** @type {any[]|Record<string, unknown>} */
     this._obj = o || [];
     /** @type {boolean | undefined} */
     this._objPropState = undefined;
     /** @type {boolean | undefined} */
     this._arrItemState = undefined;
-    /** @type {{attsObj: Record<string, any>, jmlChildren: any[]}[]} */
+    /** @type {ElementInfo[]} */
     this._elementStack = [];
+    /** @type {Record<string, unknown>} */
+    this.propertySets = {};
+    /** @type {any[]} */
+    this._docs = [];
+    /** @type {Array<{href: string, document: any, format?: string}>} */
+    this._resultDocuments = [];
   }
 
   /**
    * Directly appends an item to the internal array without checks.
-   * @param {*} item - Item to append
+   * @param {any} item - Item to append
    * @returns {void}
    */
   rawAppend (item) {
@@ -46,7 +91,7 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
 
   /**
    * Appends an item to the current object or array.
-   * @param {*} item - Item to append
+   * @param {any} item - Item to append
    * @returns {JSONJoiningTransformer}
    */
   append (item) {
@@ -66,11 +111,16 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    * Gets the current object or array. If unwrapSingleResult config option is
    * enabled and the root array contains exactly one element, returns that
    * element directly (unwrapped).
-   * @returns {any[]|object|any}
+   * @returns {any[]|Record<string, unknown>|any}
    */
   get () {
+    // If exposeDocuments is set, return the array of documents
+    if (this._cfg.exposeDocuments) {
+      return this._docs;
+    }
+    // Removed this._doc logic; use this._docs only
     // Unwrap single-element arrays at the root level if configured
-    if (this._cfg && /** @type {any} */ (this._cfg).unwrapSingleResult &&
+    if (this._cfg.unwrapSingleResult &&
         Array.isArray(this._obj) && this._obj.length === 1) {
       return this._obj[0];
     }
@@ -80,7 +130,7 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
   /**
    * Sets a property value on the current object.
    * @param {string} prop - Property name
-   * @param {*} val - Property value
+   * @param {any} val - Property value
    * @returns {void}
    */
   propValue (prop, val) {
@@ -94,16 +144,12 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
 
   /* c8 ignore next 13 -- JSDoc block incorrectly counted as coverable by c8 */
   /**
-   * @param {object|Function} [objOrCb] - Seed object to start with, or
-   *   callback if no seed provided
-   * @param {Function|any[]} [cbOrUsePropertySets] - Callback to be executed
-   *   on this transformer but with a context nested within the newly created
-   *   object, or array of property set names if first arg was an object
-   * @param {any[]|object} [usePropertySetsOrPropSets] - Array of string
-   *   property set names to copy onto the new object, or propSets if second
-   *   arg was a callback
-   * @param {object} [propSets] - An object of key-value pairs to copy onto
-   *   the new object
+   * @param {Record<string, unknown>|ObjectCallback} [objOrCb]
+   *   Seed object or callback.
+   * @param {ObjectCallback|any[]} [cbOrUsePropertySets] Callback or sets.
+   * @param {any[]|Record<string, unknown>} [usePropertySetsOrPropSets]
+   *   Sets or prop sets.
+   * @param {Record<string, unknown>} [propSets] Key-value pairs to add.
    * @returns {JSONJoiningTransformer}
    */
   object (objOrCb, cbOrUsePropertySets, usePropertySetsOrPropSets, propSets) {
@@ -124,12 +170,14 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
       obj = {};
       cb = objOrCb;
       usePropertySets = /** @type {any[]} */ (cbOrUsePropertySets);
-      propSetsToUse = /** @type {object} */ (usePropertySetsOrPropSets);
+      propSetsToUse = /** @type {Record<string, unknown>} */ (
+        usePropertySetsOrPropSets
+      );
     } else {
       // Seed object provided: object(obj, cb, usePropertySets, propSets)
       // Clone seed object to avoid mutating the original
       obj = objOrCb ? {...objOrCb} : {};
-      cb = /** @type {Function} */ (cbOrUsePropertySets);
+      cb = /** @type {ObjectCallback} */ (cbOrUsePropertySets);
       usePropertySets = /** @type {any[]} */ (usePropertySetsOrPropSets);
       propSetsToUse = propSets;
     }
@@ -144,7 +192,6 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
       Object.assign(obj, propSetsToUse);
     }
 
-    /** @type {any} */
     const oldObjPropState = this._objPropState;
     this._objPropState = true;
     this._obj = obj; // Set current object so propValue() works
@@ -162,9 +209,8 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
 
   /**
    * Creates a new array and executes a callback in its context.
-   * @param {any[]|Function} [arrOrCb] - Seed array to start with, or callback
-   *   if no seed provided
-   * @param {Function} [cb] - Callback function (if first arg was a seed array)
+   * @param {any[]|ArrayCallback} [arrOrCb] Seed array or callback.
+   * @param {ArrayCallback} [cb] Callback when first arg was array.
    * @returns {JSONJoiningTransformer}
    */
   array (arrOrCb, cb) {
@@ -200,8 +246,8 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
 
   /**
    * Appends a string value.
-   * @param {string} str - String value
-  * @param {Function} [cb] - Callback function (unused)
+   * @param {string} str String value.
+   * @param {SimpleCallback} [cb] Unused callback.
    * @returns {JSONJoiningTransformer}
    */
   string (str, cb) {
@@ -244,7 +290,7 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    * @returns {JSONJoiningTransformer}
    */
   undefined () {
-    if (this._cfg && /** @type {any} */ (this._cfg).mode !== 'JavaScript') {
+    if (this._cfg.mode !== 'JavaScript') {
       throw new Error(
         'undefined is not allowed unless added in JavaScript mode'
       );
@@ -259,7 +305,7 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    * @returns {JSONJoiningTransformer}
    */
   nonfiniteNumber (num) {
-    if (this._cfg && /** @type {any} */ (this._cfg).mode !== 'JavaScript') {
+    if (this._cfg.mode !== 'JavaScript') {
       throw new Error(
         'Non-finite numbers are not allowed unless added in JavaScript mode'
       );
@@ -270,11 +316,11 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
 
   /**
    * Appends a function value (JavaScript mode only).
-   * @param {Function} func - Function to append
+   * @param {(...args: any[]) => any} func Function to append.
    * @returns {JSONJoiningTransformer}
    */
   function (func) {
-    if (this._cfg && /** @type {any} */ (this._cfg).mode !== 'JavaScript') {
+    if (this._cfg.mode !== 'JavaScript') {
       throw new Error(
         'function is not allowed unless added in JavaScript mode'
       );
@@ -284,49 +330,67 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
   }
 
   /**
-  * Build a Jamilih-style element JSON array and append to current container.
-  * Result form: ['tag', {attr: 'val'}, child1, child2, ...]
-  * Helpers: dataset -> data-*; $a -> ordered attributes.
-  * Supported signatures mirror StringJoiningTransformer.element.
-   * @param {string|Element|object} elName - Element name or Element-like
-   * @param {object|any[]|Function} [atts] - Attributes object or children or cb
-   * @param {any[]|Function} [childNodes] - Child nodes array or callback
-   * @param {Function} [cb] - Callback for building children/attributes
+   * @param {import('./StringJoiningTransformer.js').OutputConfig} cfg
+   * @returns {JSONJoiningTransformer}
+   */
+  output (cfg) {
+    // We wait until first element is set in `element()` to add
+    //   XML declaration and DOCTYPE as latter depends on root element
+    this._outputConfig = cfg;
+
+    // Use for file extension if making downloadable?
+    this.mediaType = cfg.mediaType;
+    return this;
+  }
+
+  /**
+   * Build a Jamilih-style element JSON array and append to current container.
+   * Result form: ['tag', {attr: 'val'}, child1, child2, ...]
+   * Helpers: dataset -> data-*; $a -> ordered attributes.
+   * Supported signatures mirror StringJoiningTransformer.element.
+   * @param {string|Element} elName Element name or Element-like.
+   * @param {ElementAttributes|any[]|SimpleCallback} [atts]
+   *   Attrs, children, or cb.
+   * @param {any[]|SimpleCallback} [childNodes] Children or cb.
+   * @param {SimpleCallback} [cb] Builder callback.
    * @returns {JSONJoiningTransformer}
    */
   element (elName, atts, childNodes, cb) {
     this._requireSameChildren('json', 'element');
+    const isRoot = !this.root;
+    if (isRoot) {
+      this.root = elName;
+    }
     // Normalize arguments similarly to StringJoiningTransformer.element
     if (Array.isArray(atts)) {
-      cb = /** @type {Function} */ (childNodes);
+      cb = /** @type {SimpleCallback} */ (childNodes);
       childNodes = atts;
       atts = {};
     } else if (typeof atts === 'function') {
-      cb = /** @type {Function} */ (atts);
+      cb = /** @type {SimpleCallback} */ (atts);
       childNodes = [];
       atts = {};
     }
     if (typeof childNodes === 'function') {
-      cb = /** @type {Function} */ (childNodes);
+      cb = /** @type {SimpleCallback} */ (childNodes);
       childNodes = [];
     }
 
+    const elementName = typeof elName === 'string'
+      ? elName
+      : elName.localName;
     // Element-like object (DOM Element) -> extract attributes
     if (typeof elName === 'object' && elName && 'attributes' in elName) {
-      /** @type {Record<string, any>} */
+      /** @type {Record<string, string>} */
       const objAtts = {};
-      // @ts-ignore - treat elName as Element-like
       [...elName.attributes].forEach((att) => {
         objAtts[att.name] = att.value;
       });
       atts = Object.assign(objAtts, atts);
-      // @ts-ignore
-      elName = /** @type {any} */ (elName).nodeName;
     }
 
-    /** @type {Record<string, any>} */
-    let attsObj = /** @type {any} */ (atts) || {};
-    /** @type {any[]} */
+    let attsObj = atts || {};
+    /** @type {import('jamilih').JamilihChildren} */
     const jmlChildren = [];
 
     // Preprocess special attribute helpers present directly on attsObj
@@ -343,9 +407,9 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
       delete attsObj.dataset;
     }
     if (Array.isArray(attsObj.$a)) {
-      attsObj.$a.forEach((pair) => {
+      (/** @type {unknown[][]} */ (attsObj.$a)).forEach((pair) => {
         if (Array.isArray(pair) && pair.length > 1) {
-          attsObj[pair[0]] = pair[1];
+          attsObj[String(pair[0])] = pair[1];
         }
       });
       delete attsObj.$a;
@@ -361,7 +425,7 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
       // Push current state onto a stack
       this._elementStack.push({attsObj, jmlChildren});
       cb.call(this);
-      const state = /** @type {any} */ (this._elementStack.pop());
+      const state = /** @type {ElementInfo} */ (this._elementStack.pop());
       ({attsObj} = state);
       // Children may have been mutated by nested element()/text();
       // already in jmlChildren
@@ -369,15 +433,56 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
 
     // Build Jamilih array
     /** @type {any[]} */
-    const jmlEl = [elName];
+    const jmlEl = [elementName];
     if (Object.keys(attsObj).length) {
       jmlEl.push(attsObj);
     }
     jmlEl.push(...jmlChildren);
 
+    if (isRoot) {
+      // todo: indent, cdataSectionElements
+      const {
+        omitXmlDeclaration, doctypePublic, doctypeSystem, method
+      } = this._outputConfig ?? {};
+
+      const dtd = {$DOCTYPE: {
+        name: elementName,
+        publicId: doctypePublic ?? null, // Public ID (optional)
+        systemId: doctypeSystem ?? null // System ID (optional)
+      }};
+
+      let xmlDeclaration;
+      /* c8 ignore start -- third OR condition short-circuits */
+      if (!omitXmlDeclaration && (
+        method === 'xml' || method === 'xhtml' || omitXmlDeclaration === false)
+      ) {
+        const {version, encoding, standalone} = this._outputConfig ?? {};
+
+        xmlDeclaration = {
+          version,
+          encoding,
+          standalone
+        };
+      }
+      /* c8 ignore stop */
+
+      const doc = {$document: {
+        ...(xmlDeclaration ? {xmlDeclaration} : {}),
+        childNodes: [
+          ...(method === 'xml' || method === 'xhtml' ? [dtd] : []),
+          jmlEl
+        ]
+      }};
+
+      // Removed this._doc; use this._docs only
+      if (this._cfg.exposeDocuments) {
+        this._docs.push(doc);
+      }
+    }
+
     // If inside a parent element, append as its child; otherwise append to root
     if (this._elementStack.length) {
-      const top = /** @type {any} */ (this._elementStack.at(-1));
+      const top = /** @type {ElementInfo} */ (this._elementStack.at(-1));
       top.jmlChildren.push(jmlEl);
     } else {
       this.append(jmlEl);
@@ -390,7 +495,8 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    * a callback-driven element(). When not in an element callback context,
    * throws. Supports the same dataset/$a helpers as string joiner.
    * @param {string} name - Attribute name (or helper: dataset, $a)
-   * @param {string|object|any[]} val - Attribute value or helper object
+   * @param {string|Record<string, unknown>|unknown[]} val
+   *   Attribute value or helper object
    * @returns {JSONJoiningTransformer}
    */
   attribute (name, val) {
@@ -398,23 +504,24 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
       // No-op outside an element() callback (JSON joiner semantics)
       return this;
     }
-    const top = /** @type {any} */ (this._elementStack.at(-1));
+    const top = /** @type {ElementInfo} */ (this._elementStack.at(-1));
     const {attsObj} = top;
     if (name === 'dataset' && val && typeof val === 'object' &&
       !Array.isArray(val)
     ) {
-      for (const k in val) {
-        if (Object.hasOwn(val, k)) {
+      const datasetObj = /** @type {Record<string, unknown>} */ (val);
+      for (const k in datasetObj) {
+        if (Object.hasOwn(datasetObj, k)) {
           const dashed = k.replaceAll(camelCase, _makeDatasetAttribute);
-          attsObj['data-' + dashed] = (/** @type {any} */ (val))[k];
+          attsObj['data-' + dashed] = datasetObj[k];
         }
       }
       return this;
     }
     if (name === '$a' && Array.isArray(val)) {
-      val.forEach((pair) => {
+      (/** @type {unknown[][]} */ (val)).forEach((pair) => {
         if (Array.isArray(pair) && pair.length > 1) {
-          attsObj[pair[0]] = pair[1];
+          attsObj[String(pair[0])] = pair[1];
         }
       });
       return this;
@@ -423,6 +530,43 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
     return this;
   }
 
+  /**
+   * Adds a comment node (string) as a child within the current
+   *   element() callback context. Outside of an element callback,
+   *   simply appends the comment to the current array/object like string().
+   * @param {string} txt - Comment content
+   * @returns {JSONJoiningTransformer}
+   */
+  comment (txt) {
+    if (this._elementStack.length) {
+      const top = /** @type {ElementInfo} */ (this._elementStack.at(-1));
+      const {jmlChildren} = top;
+      jmlChildren.push(['!', txt]);
+      return this;
+    }
+    // No-op outside element context in JSON joiner
+    return this;
+  }
+
+  /**
+   * Adds a comment node (string) as a child within the current
+   *   element() callback context. Outside of an element callback,
+   *   simply appends the comment to the current array/object like string().
+   * @param {string} target - processing instruction content
+   * @param {string} data - processing instruction content
+   * @returns {JSONJoiningTransformer}
+   */
+  processingInstruction (target, data) {
+    if (this._elementStack.length) {
+      const top = /** @type {ElementInfo} */ (this._elementStack.at(-1));
+      const {jmlChildren} = top;
+      jmlChildren.push(['?', target, data]);
+      return this;
+    }
+    // No-op outside element context in JSON joiner
+    return this;
+  }
+
   /**
    * Adds a text node (string) as a child within the current element() callback
    * context. Outside of an element callback, simply appends the text to the
@@ -432,9 +576,9 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
    */
   text (txt) {
     if (this._elementStack.length) {
-      const top = /** @type {any} */ (this._elementStack.at(-1));
+      const top = /** @type {ElementInfo} */ (this._elementStack.at(-1));
       const {jmlChildren} = top;
-      jmlChildren.push(txt);
+      jmlChildren.push(['!', txt]);
       return this;
     }
     // No-op outside element context in JSON joiner
@@ -452,17 +596,154 @@ class JSONJoiningTransformer extends AbstractJoiningTransformer {
   }
 
   /**
-   * Helper method to use property sets (to be implemented).
-   * @param {object} obj - Object to apply property set to
+   * Creates a new JSON document and executes a callback in its context.
+   * Similar to XSLT's xsl:document, this allows templates to generate
+   * multiple output documents. The created document is pushed to this._docs
+   * and will be included in the result when exposeDocuments is true.
+   *
+   * @param {(this: JSONJoiningTransformer) => void} cb
+   *   Callback that builds the document content
+   * @param {import('./StringJoiningTransformer.js').OutputConfig} [cfg]
+   *   Output configuration for the document (encoding, doctype, etc.)
+   * @returns {JSONJoiningTransformer}
+   */
+  document (cb, cfg) {
+    // Save current state
+    /** @type {any} */
+    const oldRoot = this.root;
+    /** @type {any} */
+    const oldOutputConfig = this._outputConfig;
+    const oldObj = this._obj;
+    const oldElementStack = this._elementStack;
+
+    // Reset state for new document
+    this.root = undefined;
+    /** @type {any} */
+    this._outputConfig = cfg;
+    this._obj = [];
+    this._elementStack = [];
+
+    // Execute callback to build document content
+    cb.call(this);
+
+    // Restore previous state
+    this.root = oldRoot;
+    this._outputConfig = oldOutputConfig;
+    this._obj = oldObj;
+    this._elementStack = oldElementStack;
+
+    return this;
+  }
+
+  /**
+   * Creates a new result document with metadata (href, format).
+   * Similar to XSLT's xsl:result-document, this allows templates to generate
+   * multiple output documents with associated metadata like URIs. The created
+   * document is stored in this._resultDocuments with the provided href.
+   *
+   * @param {string} href - URI/path for the result document
+   * @param {(this: JSONJoiningTransformer) => void} cb
+   *   Callback that builds the document content
+   * @param {import('./StringJoiningTransformer.js').OutputConfig} [cfg]
+   *   Output configuration for the document (encoding, doctype, format, etc.)
+   * @returns {JSONJoiningTransformer}
+   */
+  resultDocument (href, cb, cfg) {
+    // Save current state
+    /** @type {any} */
+    const oldRoot = this.root;
+    /** @type {any} */
+    const oldOutputConfig = this._outputConfig;
+    const oldObj = this._obj;
+    const oldElementStack = this._elementStack;
+
+    // Reset state for new document
+    this.root = undefined;
+    /** @type {any} */
+    this._outputConfig = cfg;
+    this._obj = [];
+    this._elementStack = [];
+
+    // Execute callback to build document content
+    cb.call(this);
+
+    // Get the created document from _docs or construct from current state
+    let resultDoc;
+    if (this._docs.length > 0) {
+      // Document was created with exposeDocuments flag
+      resultDoc = this._docs.at(-1);
+    } else if (this._outputConfig) {
+      // We have output config but document wasn't pushed to _docs
+      // Create the document wrapper manually
+      const {
+        omitXmlDeclaration, doctypePublic, doctypeSystem, method
+      } = this._outputConfig;
+
+      const elementData = Array.isArray(this._obj) && this._obj.length > 0
+        ? this._obj[0]
+        : this._obj;
+
+      const elementName = Array.isArray(elementData) ? elementData[0] : 'root';
+
+      const dtd = {$DOCTYPE: {
+        name: elementName,
+        publicId: doctypePublic ?? null,
+        systemId: doctypeSystem ?? null
+      }};
+
+      let xmlDeclaration;
+      /* c8 ignore start -- third OR condition short-circuits */
+      if (!omitXmlDeclaration && (
+        method === 'xml' || method === 'xhtml' || omitXmlDeclaration === false)
+      ) {
+        const {version, encoding, standalone} = this._outputConfig;
+        xmlDeclaration = {
+          version,
+          encoding,
+          standalone
+        };
+      }
+      /* c8 ignore stop */
+
+      resultDoc = {$document: {
+        ...(xmlDeclaration ? {xmlDeclaration} : {}),
+        childNodes: [
+          ...(method === 'xml' || method === 'xhtml' ? [dtd] : []),
+          elementData
+        ]
+      }};
+    } else {
+      // No output config, just use the raw object/array
+      resultDoc = this._obj;
+    }
+
+    // Store with metadata, using the output config that was set during callback
+    this._resultDocuments.push({
+      href,
+      document: resultDoc,
+      format: this._outputConfig?.method || cfg?.method
+    });
+
+    // Restore previous state
+    this.root = oldRoot;
+    this._outputConfig = oldOutputConfig;
+    this._obj = oldObj;
+    this._elementStack = oldElementStack;
+
+    return this;
+  }
+
+  /**
+   * Helper method to use property sets.
+   * @param {Record<string, unknown>} obj - Object to which to apply
+   *   property set
    * @param {string} psName - Property set name
-   * @returns {object}
+   * @returns {Record<string, unknown>}
    */
   _usePropertySets (obj, psName) {
     // Merge the named property set (if present) into the provided object
-    if (this && /** @type {any} */ (this).propertySets &&
-    /** @type {any} */ (this).propertySets[psName]
-    ) {
-      return Object.assign(obj, /** @type {any} */ (this).propertySets[psName]);
+    if (this.propertySets[psName]) {
+      return Object.assign(obj, this.propertySets[psName]);
     }
     return obj;
   }