ngx-smz-ui 16.4.28 → 16.4.30

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -8,13 +8,12 @@ export class SmzPropertyBasedDataSourceTreeBuilder extends SmzBuilderUtilities {
8
8
  this._config = {
9
9
  labelProperty: 'name',
10
10
  keyProperty: 'id',
11
- rootType: 'root',
12
11
  includeData: false,
13
- nodes: []
12
+ nodes: [{ property: null, type: 'root', getTypeCallback: null }]
14
13
  };
15
14
  }
16
- setRootType(type) {
17
- this._config.rootType = type;
15
+ addRootRelation(type) {
16
+ this._config.nodes.find(x => x.property == null).type = type;
18
17
  return this.that;
19
18
  }
20
19
  setLabelProperty(property) {
@@ -36,18 +35,34 @@ export class SmzPropertyBasedDataSourceTreeBuilder extends SmzBuilderUtilities {
36
35
  this._config.nodes.push({ property, type, getTypeCallback: null });
37
36
  return this.that;
38
37
  }
39
- addConditionalRelation(property, getTypeCallback) {
38
+ addConditionalRootRelation(getTypeCallback) {
39
+ const rootConfig = this._config.nodes.find(x => x.property == null);
40
+ if (rootConfig.getTypeCallback != null) {
41
+ throw Error("You can't apply a Conditional Relation more than once to the Root Node.");
42
+ }
43
+ rootConfig.type = null;
44
+ rootConfig.getTypeCallback = getTypeCallback;
45
+ return this.that;
46
+ }
47
+ addConditionalRelation(property, getTypeCallback, alsoApplyToRoot = false) {
40
48
  if (this._config.nodes.some(x => x.property === property)) {
41
49
  throw Error("You can't call addConditionalRelation for a property already with relation set.");
42
50
  }
43
51
  this._config.nodes.push({ property, type: null, getTypeCallback });
52
+ if (alsoApplyToRoot) {
53
+ const rootConfig = this._config.nodes.find(x => x.property == null);
54
+ if (rootConfig.getTypeCallback != null) {
55
+ throw Error("You can't apply a Conditional Relation more than once to the Root Node.");
56
+ }
57
+ rootConfig.getTypeCallback = getTypeCallback;
58
+ }
44
59
  return this.that;
45
60
  }
46
61
  get dataSource() {
47
62
  if (this._config != null) {
48
- this._content.dataTransform = (items) => {
63
+ this._content.dataTransform = (options) => {
49
64
  // Mapeia cada item do array para um TreeNode usando createTreeFromPropertyBasedConfig
50
- const trees = items.map(item => createTreeFromPropertyBasedConfig(item, this._config)).filter(tree => tree !== null);
65
+ const trees = options.map(item => createTreeFromPropertyBasedConfig(item, this._config)).filter(tree => tree !== null);
51
66
  return trees.length > 0 ? trees : [];
52
67
  };
53
68
  }
@@ -57,19 +72,28 @@ export class SmzPropertyBasedDataSourceTreeBuilder extends SmzBuilderUtilities {
57
72
  function createTreeFromPropertyBasedConfig(item, config) {
58
73
  if (!item || typeof item !== 'object')
59
74
  return null; // Garante que o item é um objeto
60
- const rootNode = { label: item[config.labelProperty] ?? 'Unknown', type: config.rootType, key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };
75
+ let rootNode = {};
76
+ const rootNodeConfig = config.nodes.find(x => x.property == null);
77
+ if (rootNodeConfig.getTypeCallback != null) {
78
+ rootNode = { label: item[config.labelProperty] ?? 'Unknown', type: rootNodeConfig.getTypeCallback(item), key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };
79
+ }
80
+ else {
81
+ rootNode = { label: item[config.labelProperty] ?? 'Unknown', type: rootNodeConfig.type, key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };
82
+ }
61
83
  // Processa cada configuração de nó para adicionar crianças diretamente sem agrupá-las por tipo
62
- config.nodes.forEach(({ property, type, getTypeCallback }) => {
84
+ config.nodes
85
+ .filter(x => x.property != null)
86
+ .forEach(({ property, type, getTypeCallback }) => {
63
87
  const propertyValue = item[property];
64
88
  if (Array.isArray(propertyValue)) {
65
89
  // Para cada item na propriedade, cria um novo nó
66
90
  propertyValue.forEach(subItem => {
67
91
  let childNode = null;
68
92
  if (getTypeCallback != null) {
69
- childNode = buildNode(subItem, property, getTypeCallback(subItem), config); // Aqui usamos property ao invés de type para construir o nó
93
+ childNode = buildNode(subItem, getTypeCallback(subItem), config); // Aqui usamos property ao invés de type para construir o nó
70
94
  }
71
95
  else if (type != null) {
72
- childNode = buildNode(subItem, property, type, config); // Aqui usamos property ao invés de type para construir o nó
96
+ childNode = buildNode(subItem, type, config); // Aqui usamos property ao invés de type para construir o nó
73
97
  }
74
98
  if (childNode) {
75
99
  rootNode.children?.push(childNode); // Adiciona o nó filho diretamente ao rootNode
@@ -79,7 +103,7 @@ function createTreeFromPropertyBasedConfig(item, config) {
79
103
  });
80
104
  return rootNode;
81
105
  }
82
- function buildNode(item, property, type, config) {
106
+ function buildNode(item, type, config) {
83
107
  if (!item || typeof item !== 'object')
84
108
  return null;
85
109
  // Cria um novo TreeNode sem levar em conta o type, apenas usa a labelProperty para o rótulo
@@ -91,16 +115,18 @@ function buildNode(item, property, type, config) {
91
115
  children: [],
92
116
  };
93
117
  // Verifica se há mais filhos a serem adicionados com base na configuração
94
- config.nodes.forEach(configItem => {
118
+ config.nodes
119
+ .filter(x => x.property != null)
120
+ .forEach(configItem => {
95
121
  const items = item[configItem.property];
96
122
  if (Array.isArray(items)) {
97
123
  items.forEach(subItem => {
98
124
  let childNode = null;
99
125
  if (configItem.getTypeCallback != null) {
100
- childNode = buildNode(subItem, configItem.property, configItem.getTypeCallback(subItem), config);
126
+ childNode = buildNode(subItem, configItem.getTypeCallback(subItem), config);
101
127
  }
102
128
  else if (type != null) {
103
- childNode = buildNode(subItem, configItem.property, configItem.type, config);
129
+ childNode = buildNode(subItem, configItem.type, config);
104
130
  }
105
131
  if (childNode) {
106
132
  node.children?.push(childNode);
@@ -110,4 +136,4 @@ function buildNode(item, property, type, config) {
110
136
  });
111
137
  return node;
112
138
  }
113
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property-based-data-source-tree-builder.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smz-ui/src/lib/builders/smz-trees/property-based-data-source-tree-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { SmzTreeSourceTransform } from '../../modules/smz-trees/models/tree-state';\r\nimport { SmzBuilderUtilities } from '../common/smz-builder-utilities';\r\nimport { SmzDataSourceTreeBuilder } from './data-source-tree-builder';\r\nimport { TreeNode } from 'primeng/api';\r\nimport { ObjectUtils } from 'primeng/utils';\r\n\r\nexport class SmzPropertyBasedDataSourceTreeBuilder<TBuilder> extends SmzBuilderUtilities<SmzPropertyBasedDataSourceTreeBuilder<TBuilder>> {\r\n  protected that = this;\r\n  private _config: SmzTreePropertyBasedConfig = {\r\n    labelProperty: 'name',\r\n    keyProperty: 'id',\r\n    rootType: 'root',\r\n    includeData: false,\r\n    nodes: []\r\n  };\r\n  constructor(private _content: SmzTreeSourceTransform, private _dataSourceBuilder: SmzDataSourceTreeBuilder<TBuilder>) {\r\n    super();\r\n  }\r\n\r\n  public setRootType(type: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n    this._config.rootType = type;\r\n    return this.that;\r\n  }\r\n\r\n  public setLabelProperty(property: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n    this._config.labelProperty = property;\r\n    return this.that;\r\n  }\r\n\r\n  public setKeyProperty(property: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n    this._config.keyProperty = property;\r\n    return this.that;\r\n  }\r\n\r\n  public includeData(): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n    this._config.includeData = true;\r\n    return this.that;\r\n  }\r\n\r\n  public addRelation(property: string, type: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n\r\n    if (this._config.nodes.some(x => x.property === property)) {\r\n      throw Error(\"You can't call addRelation for a property already with relation set.\");\r\n    }\r\n\r\n    this._config.nodes.push({ property, type, getTypeCallback: null });\r\n    return this.that;\r\n  }\r\n\r\n  public addConditionalRelation<TNodeData>(property: string, getTypeCallback: (node: TNodeData) => string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n\r\n    if (this._config.nodes.some(x => x.property === property)) {\r\n      throw Error(\"You can't call addConditionalRelation for a property already with relation set.\");\r\n    }\r\n\r\n    this._config.nodes.push({ property, type: null, getTypeCallback });\r\n    return this.that;\r\n  }\r\n\r\n  public get dataSource(): SmzDataSourceTreeBuilder<TBuilder> {\r\n\r\n    if (this._config != null) {\r\n\r\n      this._content.dataTransform = (items: any[]) => {\r\n\r\n        // Mapeia cada item do array para um TreeNode usando createTreeFromPropertyBasedConfig\r\n        const trees = items.map(item => createTreeFromPropertyBasedConfig(item, this._config)).filter(tree => tree !== null);\r\n\r\n        return trees.length > 0 ? trees : [];\r\n      }\r\n    }\r\n\r\n    return this._dataSourceBuilder;\r\n  }\r\n\r\n}\r\n\r\nfunction createTreeFromPropertyBasedConfig(item: any, config: SmzTreePropertyBasedConfig): TreeNode | null {\r\n  if (!item || typeof item !== 'object') return null; // Garante que o item é um objeto\r\n\r\n  const rootNode: TreeNode = { label: item[config.labelProperty] ?? 'Unknown', type: config.rootType, key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };\r\n\r\n  // Processa cada configuração de nó para adicionar crianças diretamente sem agrupá-las por tipo\r\n  config.nodes.forEach(({ property, type, getTypeCallback }) => {\r\n    const propertyValue = item[property];\r\n    if (Array.isArray(propertyValue)) {\r\n      // Para cada item na propriedade, cria um novo nó\r\n      propertyValue.forEach(subItem => {\r\n\r\n        let childNode: TreeNode<any> = null;\r\n\r\n        if (getTypeCallback != null) {\r\n          childNode = buildNode(subItem, property, getTypeCallback(subItem), config); // Aqui usamos property ao invés de type para construir o nó\r\n        }\r\n        else if (type != null) {\r\n          childNode = buildNode(subItem, property, type, config); // Aqui usamos property ao invés de type para construir o nó\r\n        }\r\n\r\n        if (childNode) {\r\n          rootNode.children?.push(childNode); // Adiciona o nó filho diretamente ao rootNode\r\n        }\r\n      });\r\n    }\r\n  });\r\n\r\n  return rootNode;\r\n}\r\n\r\nfunction buildNode(item: any, property: string, type: string, config: SmzTreePropertyBasedConfig): TreeNode | null {\r\n  if (!item || typeof item !== 'object') return null;\r\n\r\n  // Cria um novo TreeNode sem levar em conta o type, apenas usa a labelProperty para o rótulo\r\n  const node: TreeNode = {\r\n    label: item[config.labelProperty] ?? 'Unknown',\r\n    data: config.includeData ? item : undefined,\r\n    type,\r\n    key: item[config.keyProperty] ?? 'Unknown',\r\n    children: [],\r\n  };\r\n\r\n  // Verifica se há mais filhos a serem adicionados com base na configuração\r\n  config.nodes.forEach(configItem => {\r\n    const items = item[configItem.property];\r\n    if (Array.isArray(items)) {\r\n      items.forEach(subItem => {\r\n\r\n        let childNode: TreeNode<any> = null;\r\n\r\n        if (configItem.getTypeCallback != null) {\r\n          childNode = buildNode(subItem, configItem.property, configItem.getTypeCallback(subItem), config);\r\n        }\r\n        else if (type != null) {\r\n          childNode = buildNode(subItem, configItem.property, configItem.type, config);\r\n        }\r\n\r\n        if (childNode) {\r\n          node.children?.push(childNode);\r\n        }\r\n      });\r\n    }\r\n  });\r\n\r\n  return node;\r\n}\r\n\r\nexport interface SmzTreePropertyBasedConfig {\r\n  labelProperty: string;\r\n  keyProperty: string;\r\n  rootType: string;\r\n  includeData: boolean;\r\n  nodes: {\r\n    property: string;\r\n    type: string;\r\n    getTypeCallback: (node: TreeNode) => string\r\n  }[]\r\n}"]}
139
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property-based-data-source-tree-builder.js","sourceRoot":"","sources":["../../../../../../projects/ngx-smz-ui/src/lib/builders/smz-trees/property-based-data-source-tree-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import { SmzTreeSourceTransform } from '../../modules/smz-trees/models/tree-state';\r\nimport { SmzBuilderUtilities } from '../common/smz-builder-utilities';\r\nimport { SmzDataSourceTreeBuilder } from './data-source-tree-builder';\r\nimport { TreeNode } from 'primeng/api';\r\nimport { ObjectUtils } from 'primeng/utils';\r\n\r\nexport class SmzPropertyBasedDataSourceTreeBuilder<TBuilder> extends SmzBuilderUtilities<SmzPropertyBasedDataSourceTreeBuilder<TBuilder>> {\r\n  protected that = this;\r\n  private _config: SmzTreePropertyBasedConfig = {\r\n    labelProperty: 'name',\r\n    keyProperty: 'id',\r\n    includeData: false,\r\n    nodes: [{ property: null, type: 'root', getTypeCallback: null }]\r\n  };\r\n  constructor(private _content: SmzTreeSourceTransform, private _dataSourceBuilder: SmzDataSourceTreeBuilder<TBuilder>) {\r\n    super();\r\n  }\r\n\r\n  public addRootRelation(type: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n    this._config.nodes.find(x => x.property == null).type = type;\r\n    return this.that;\r\n  }\r\n\r\n  public setLabelProperty(property: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n    this._config.labelProperty = property;\r\n    return this.that;\r\n  }\r\n\r\n  public setKeyProperty(property: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n    this._config.keyProperty = property;\r\n    return this.that;\r\n  }\r\n\r\n  public includeData(): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n    this._config.includeData = true;\r\n    return this.that;\r\n  }\r\n\r\n  public addRelation(property: string, type: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n\r\n    if (this._config.nodes.some(x => x.property === property)) {\r\n      throw Error(\"You can't call addRelation for a property already with relation set.\");\r\n    }\r\n\r\n    this._config.nodes.push({ property, type, getTypeCallback: null });\r\n    return this.that;\r\n  }\r\n\r\n  public addConditionalRootRelation<TNodeData>(getTypeCallback: (node: TNodeData) => string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n\r\n    const rootConfig = this._config.nodes.find(x => x.property == null);\r\n\r\n    if (rootConfig.getTypeCallback != null) {\r\n      throw Error(\"You can't apply a Conditional Relation more than once to the Root Node.\");\r\n    }\r\n\r\n    rootConfig.type = null;\r\n    rootConfig.getTypeCallback = getTypeCallback;\r\n\r\n    return this.that;\r\n  }\r\n\r\n  public addConditionalRelation<TNodeData>(property: string, getTypeCallback: (node: TNodeData) => string, alsoApplyToRoot: boolean = false): SmzPropertyBasedDataSourceTreeBuilder<TBuilder> {\r\n\r\n    if (this._config.nodes.some(x => x.property === property)) {\r\n      throw Error(\"You can't call addConditionalRelation for a property already with relation set.\");\r\n    }\r\n\r\n    this._config.nodes.push({ property, type: null, getTypeCallback });\r\n\r\n    if (alsoApplyToRoot) {\r\n\r\n      const rootConfig = this._config.nodes.find(x => x.property == null);\r\n\r\n      if (rootConfig.getTypeCallback != null) {\r\n        throw Error(\"You can't apply a Conditional Relation more than once to the Root Node.\");\r\n      }\r\n\r\n      rootConfig.getTypeCallback = getTypeCallback;\r\n\r\n    }\r\n\r\n    return this.that;\r\n  }\r\n\r\n  public get dataSource(): SmzDataSourceTreeBuilder<TBuilder> {\r\n\r\n    if (this._config != null) {\r\n\r\n      this._content.dataTransform = (options: any[]) => {\r\n\r\n        // Mapeia cada item do array para um TreeNode usando createTreeFromPropertyBasedConfig\r\n        const trees = options.map(item => createTreeFromPropertyBasedConfig(item, this._config)).filter(tree => tree !== null);\r\n\r\n        return trees.length > 0 ? trees : [];\r\n      }\r\n    }\r\n\r\n    return this._dataSourceBuilder;\r\n  }\r\n\r\n}\r\n\r\nfunction createTreeFromPropertyBasedConfig(item: any, config: SmzTreePropertyBasedConfig): TreeNode | null {\r\n  if (!item || typeof item !== 'object') return null; // Garante que o item é um objeto\r\n\r\n  let rootNode: TreeNode = {};\r\n\r\n  const rootNodeConfig = config.nodes.find(x => x.property == null);\r\n\r\n  if (rootNodeConfig.getTypeCallback != null) {\r\n      rootNode = { label: item[config.labelProperty] ?? 'Unknown', type: rootNodeConfig.getTypeCallback(item), key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };\r\n  }\r\n  else {\r\n    rootNode = { label: item[config.labelProperty] ?? 'Unknown', type: rootNodeConfig.type, key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };\r\n  }\r\n\r\n  // Processa cada configuração de nó para adicionar crianças diretamente sem agrupá-las por tipo\r\n  config.nodes\r\n    .filter(x => x.property != null)\r\n    .forEach(({ property, type, getTypeCallback }) => {\r\n      const propertyValue = item[property];\r\n      if (Array.isArray(propertyValue)) {\r\n        // Para cada item na propriedade, cria um novo nó\r\n        propertyValue.forEach(subItem => {\r\n\r\n          let childNode: TreeNode<any> = null;\r\n\r\n          if (getTypeCallback != null) {\r\n            childNode = buildNode(subItem, getTypeCallback(subItem), config); // Aqui usamos property ao invés de type para construir o nó\r\n          }\r\n          else if (type != null) {\r\n            childNode = buildNode(subItem, type, config); // Aqui usamos property ao invés de type para construir o nó\r\n          }\r\n\r\n          if (childNode) {\r\n            rootNode.children?.push(childNode); // Adiciona o nó filho diretamente ao rootNode\r\n          }\r\n        });\r\n    }\r\n  });\r\n\r\n  return rootNode;\r\n}\r\n\r\nfunction buildNode(item: any, type: string, config: SmzTreePropertyBasedConfig): TreeNode | null {\r\n  if (!item || typeof item !== 'object') return null;\r\n\r\n  // Cria um novo TreeNode sem levar em conta o type, apenas usa a labelProperty para o rótulo\r\n  const node: TreeNode = {\r\n    label: item[config.labelProperty] ?? 'Unknown',\r\n    data: config.includeData ? item : undefined,\r\n    type,\r\n    key: item[config.keyProperty] ?? 'Unknown',\r\n    children: [],\r\n  };\r\n\r\n  // Verifica se há mais filhos a serem adicionados com base na configuração\r\n  config.nodes\r\n    .filter(x => x.property != null)\r\n    .forEach(configItem => {\r\n      const items = item[configItem.property];\r\n      if (Array.isArray(items)) {\r\n        items.forEach(subItem => {\r\n\r\n          let childNode: TreeNode<any> = null;\r\n\r\n          if (configItem.getTypeCallback != null) {\r\n            childNode = buildNode(subItem, configItem.getTypeCallback(subItem), config);\r\n          }\r\n          else if (type != null) {\r\n            childNode = buildNode(subItem, configItem.type, config);\r\n          }\r\n\r\n          if (childNode) {\r\n            node.children?.push(childNode);\r\n          }\r\n        });\r\n      }\r\n    });\r\n\r\n  return node;\r\n}\r\n\r\nexport interface SmzTreePropertyBasedConfig {\r\n  labelProperty: string;\r\n  keyProperty: string;\r\n  includeData: boolean;\r\n  nodes: {\r\n    property: string;\r\n    type: string;\r\n    getTypeCallback: (node: TreeNode) => string\r\n  }[]\r\n}"]}
@@ -22794,13 +22794,12 @@ class SmzPropertyBasedDataSourceTreeBuilder extends SmzBuilderUtilities {
22794
22794
  this._config = {
22795
22795
  labelProperty: 'name',
22796
22796
  keyProperty: 'id',
22797
- rootType: 'root',
22798
22797
  includeData: false,
22799
- nodes: []
22798
+ nodes: [{ property: null, type: 'root', getTypeCallback: null }]
22800
22799
  };
22801
22800
  }
22802
- setRootType(type) {
22803
- this._config.rootType = type;
22801
+ addRootRelation(type) {
22802
+ this._config.nodes.find(x => x.property == null).type = type;
22804
22803
  return this.that;
22805
22804
  }
22806
22805
  setLabelProperty(property) {
@@ -22822,18 +22821,34 @@ class SmzPropertyBasedDataSourceTreeBuilder extends SmzBuilderUtilities {
22822
22821
  this._config.nodes.push({ property, type, getTypeCallback: null });
22823
22822
  return this.that;
22824
22823
  }
22825
- addConditionalRelation(property, getTypeCallback) {
22824
+ addConditionalRootRelation(getTypeCallback) {
22825
+ const rootConfig = this._config.nodes.find(x => x.property == null);
22826
+ if (rootConfig.getTypeCallback != null) {
22827
+ throw Error("You can't apply a Conditional Relation more than once to the Root Node.");
22828
+ }
22829
+ rootConfig.type = null;
22830
+ rootConfig.getTypeCallback = getTypeCallback;
22831
+ return this.that;
22832
+ }
22833
+ addConditionalRelation(property, getTypeCallback, alsoApplyToRoot = false) {
22826
22834
  if (this._config.nodes.some(x => x.property === property)) {
22827
22835
  throw Error("You can't call addConditionalRelation for a property already with relation set.");
22828
22836
  }
22829
22837
  this._config.nodes.push({ property, type: null, getTypeCallback });
22838
+ if (alsoApplyToRoot) {
22839
+ const rootConfig = this._config.nodes.find(x => x.property == null);
22840
+ if (rootConfig.getTypeCallback != null) {
22841
+ throw Error("You can't apply a Conditional Relation more than once to the Root Node.");
22842
+ }
22843
+ rootConfig.getTypeCallback = getTypeCallback;
22844
+ }
22830
22845
  return this.that;
22831
22846
  }
22832
22847
  get dataSource() {
22833
22848
  if (this._config != null) {
22834
- this._content.dataTransform = (items) => {
22849
+ this._content.dataTransform = (options) => {
22835
22850
  // Mapeia cada item do array para um TreeNode usando createTreeFromPropertyBasedConfig
22836
- const trees = items.map(item => createTreeFromPropertyBasedConfig(item, this._config)).filter(tree => tree !== null);
22851
+ const trees = options.map(item => createTreeFromPropertyBasedConfig(item, this._config)).filter(tree => tree !== null);
22837
22852
  return trees.length > 0 ? trees : [];
22838
22853
  };
22839
22854
  }
@@ -22843,19 +22858,28 @@ class SmzPropertyBasedDataSourceTreeBuilder extends SmzBuilderUtilities {
22843
22858
  function createTreeFromPropertyBasedConfig(item, config) {
22844
22859
  if (!item || typeof item !== 'object')
22845
22860
  return null; // Garante que o item é um objeto
22846
- const rootNode = { label: item[config.labelProperty] ?? 'Unknown', type: config.rootType, key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };
22861
+ let rootNode = {};
22862
+ const rootNodeConfig = config.nodes.find(x => x.property == null);
22863
+ if (rootNodeConfig.getTypeCallback != null) {
22864
+ rootNode = { label: item[config.labelProperty] ?? 'Unknown', type: rootNodeConfig.getTypeCallback(item), key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };
22865
+ }
22866
+ else {
22867
+ rootNode = { label: item[config.labelProperty] ?? 'Unknown', type: rootNodeConfig.type, key: item[config.keyProperty], data: config.includeData ? item : undefined, children: [] };
22868
+ }
22847
22869
  // Processa cada configuração de nó para adicionar crianças diretamente sem agrupá-las por tipo
22848
- config.nodes.forEach(({ property, type, getTypeCallback }) => {
22870
+ config.nodes
22871
+ .filter(x => x.property != null)
22872
+ .forEach(({ property, type, getTypeCallback }) => {
22849
22873
  const propertyValue = item[property];
22850
22874
  if (Array.isArray(propertyValue)) {
22851
22875
  // Para cada item na propriedade, cria um novo nó
22852
22876
  propertyValue.forEach(subItem => {
22853
22877
  let childNode = null;
22854
22878
  if (getTypeCallback != null) {
22855
- childNode = buildNode(subItem, property, getTypeCallback(subItem), config); // Aqui usamos property ao invés de type para construir o nó
22879
+ childNode = buildNode(subItem, getTypeCallback(subItem), config); // Aqui usamos property ao invés de type para construir o nó
22856
22880
  }
22857
22881
  else if (type != null) {
22858
- childNode = buildNode(subItem, property, type, config); // Aqui usamos property ao invés de type para construir o nó
22882
+ childNode = buildNode(subItem, type, config); // Aqui usamos property ao invés de type para construir o nó
22859
22883
  }
22860
22884
  if (childNode) {
22861
22885
  rootNode.children?.push(childNode); // Adiciona o nó filho diretamente ao rootNode
@@ -22865,7 +22889,7 @@ function createTreeFromPropertyBasedConfig(item, config) {
22865
22889
  });
22866
22890
  return rootNode;
22867
22891
  }
22868
- function buildNode(item, property, type, config) {
22892
+ function buildNode(item, type, config) {
22869
22893
  if (!item || typeof item !== 'object')
22870
22894
  return null;
22871
22895
  // Cria um novo TreeNode sem levar em conta o type, apenas usa a labelProperty para o rótulo
@@ -22877,16 +22901,18 @@ function buildNode(item, property, type, config) {
22877
22901
  children: [],
22878
22902
  };
22879
22903
  // Verifica se há mais filhos a serem adicionados com base na configuração
22880
- config.nodes.forEach(configItem => {
22904
+ config.nodes
22905
+ .filter(x => x.property != null)
22906
+ .forEach(configItem => {
22881
22907
  const items = item[configItem.property];
22882
22908
  if (Array.isArray(items)) {
22883
22909
  items.forEach(subItem => {
22884
22910
  let childNode = null;
22885
22911
  if (configItem.getTypeCallback != null) {
22886
- childNode = buildNode(subItem, configItem.property, configItem.getTypeCallback(subItem), config);
22912
+ childNode = buildNode(subItem, configItem.getTypeCallback(subItem), config);
22887
22913
  }
22888
22914
  else if (type != null) {
22889
- childNode = buildNode(subItem, configItem.property, configItem.type, config);
22915
+ childNode = buildNode(subItem, configItem.type, config);
22890
22916
  }
22891
22917
  if (childNode) {
22892
22918
  node.children?.push(childNode);