zinggrid-metadata 1.0.0 → 1.0.1
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.
- package/README.md +3 -1
- package/content-model-schema.json +428 -0
- package/package.json +4 -1
package/README.md
CHANGED
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
# ZingGrid Metadata
|
|
2
2
|
|
|
3
|
-
This repository contains the capabilities metadata and feature registry for ZingGrid.
|
|
3
|
+
This repository contains the content model schema, capabilities metadata and feature registry for ZingGrid.
|
|
4
|
+
|
|
5
|
+
The content model schema defines the allowed parent–child relationships between elements, specifying which elements may contain or be nested within others.
|
|
4
6
|
|
|
5
7
|
The capabilities metadata defines the configuration contract for each component, including required and disallowed attributes.
|
|
6
8
|
|
|
@@ -0,0 +1,428 @@
|
|
|
1
|
+
{
|
|
2
|
+
"components": [
|
|
3
|
+
{
|
|
4
|
+
"name": "zg-batch-edit",
|
|
5
|
+
"description": "The `<zg-batch-edit>` element is used to define the batch edit region. \n`<zg-batch-edit>` is created internally and should not be placed directly in the user's HTML; however,\nthe user can style the `<zg-batch-edit>` using the `zg-batch-edit` selector.",
|
|
6
|
+
"allowedChildren": [],
|
|
7
|
+
"requiredChildren": [],
|
|
8
|
+
"requiredAttributes": []
|
|
9
|
+
},
|
|
10
|
+
{
|
|
11
|
+
"name": "zg-body",
|
|
12
|
+
"description": "`<zg-body>` is created dynamically by the ZingGrid library, and as such should not be manually added by the\ndeveloper. However the user can style `<zg-body>` using CSS.",
|
|
13
|
+
"allowedChildren": [],
|
|
14
|
+
"requiredChildren": [],
|
|
15
|
+
"requiredAttributes": []
|
|
16
|
+
},
|
|
17
|
+
{
|
|
18
|
+
"name": "zg-button",
|
|
19
|
+
"description": "A custom, styled button that can be used both for internal grid-related action and for user-specific\nactions. It is stylable via CSS. Some buttons are automatically inserted when a feature that uses it enabled, like `pager`, while\nothers are inserted manually by the user.",
|
|
20
|
+
"allowedChildren": [
|
|
21
|
+
"zg-icon"
|
|
22
|
+
],
|
|
23
|
+
"requiredChildren": [],
|
|
24
|
+
"requiredAttributes": []
|
|
25
|
+
},
|
|
26
|
+
{
|
|
27
|
+
"name": "zg-caption",
|
|
28
|
+
"description": "A caption can be manually inserted inside the `<zing-grid>` tag as slotted content or automatically\ninserted when the `caption` is enabled. `<zg-caption>` is stylable via CSS.",
|
|
29
|
+
"allowedChildren": [
|
|
30
|
+
"zg-button",
|
|
31
|
+
"zg-checkbox",
|
|
32
|
+
"zg-icon",
|
|
33
|
+
"zg-input",
|
|
34
|
+
"zg-select",
|
|
35
|
+
"zg-text",
|
|
36
|
+
"*"
|
|
37
|
+
],
|
|
38
|
+
"requiredChildren": [],
|
|
39
|
+
"requiredAttributes": []
|
|
40
|
+
},
|
|
41
|
+
{
|
|
42
|
+
"name": "zg-card",
|
|
43
|
+
"description": "The container for a card template that holds a custom template for card mode. This custom template\nwill be rendered per row. `<zg-card>` can be styled via CSS or the `--zg-card-*` selectors. Please reference\nthe \"Template\" section for more details on templates.",
|
|
44
|
+
"allowedChildren": [
|
|
45
|
+
"zg-button",
|
|
46
|
+
"zg-checkbox",
|
|
47
|
+
"zg-icon",
|
|
48
|
+
"zg-input",
|
|
49
|
+
"zg-select",
|
|
50
|
+
"zg-text"
|
|
51
|
+
],
|
|
52
|
+
"requiredChildren": [],
|
|
53
|
+
"requiredAttributes": []
|
|
54
|
+
},
|
|
55
|
+
{
|
|
56
|
+
"name": "zg-cell",
|
|
57
|
+
"description": "`<zg-cell>` is the container for a single cell;\nit corresponds to the `<td>` tag on an HTML table. It is automatically inserted and should not \nbe placed directly in the user's HTML. `<zg-cell>` can be styled via CSS.",
|
|
58
|
+
"allowedChildren": [],
|
|
59
|
+
"requiredChildren": [],
|
|
60
|
+
"requiredAttributes": []
|
|
61
|
+
},
|
|
62
|
+
{
|
|
63
|
+
"name": "zg-cell-overflow",
|
|
64
|
+
"description": "`<zg-cell-overflow>` elements can be used to add popup data to each cell on a user action. Typical use would\nbe a custom element select and optionlist. As a generated element, developers\nshould not manually place `<zg-cell-overflow>` in their grid; however, they may style the tooltips and\nits internal elements using CSS.",
|
|
65
|
+
"allowedChildren": [],
|
|
66
|
+
"requiredChildren": [],
|
|
67
|
+
"requiredAttributes": []
|
|
68
|
+
},
|
|
69
|
+
{
|
|
70
|
+
"name": "zg-checkbox",
|
|
71
|
+
"description": "A checkbox is automatically inserted when\na feature that uses it is enabled, like `<zg-column type=\"selector\">`, or it can be manually-inserted\nto the grid. It can be styled via CSS.",
|
|
72
|
+
"allowedChildren": [],
|
|
73
|
+
"requiredChildren": [],
|
|
74
|
+
"requiredAttributes": []
|
|
75
|
+
},
|
|
76
|
+
{
|
|
77
|
+
"name": "zg-colgroup",
|
|
78
|
+
"description": "`<zg-colgroup>` is a container for the columns of the grid specified by `<zg-column>` tags. \nThis element is similar in function to the `<colgroup>` tag in an HTML element. \nDevelopers should always add this element to their grid structure; however, ZingGrid will insert it \nautomatically if it is omitted. As an non-visual element, you should not apply style to this tag.\nNote: Omission of `<zg-colgroup>` may result in a slight performance delay for auto-insertion.",
|
|
79
|
+
"allowedChildren": [
|
|
80
|
+
"zg-column"
|
|
81
|
+
],
|
|
82
|
+
"requiredChildren": [],
|
|
83
|
+
"requiredAttributes": []
|
|
84
|
+
},
|
|
85
|
+
{
|
|
86
|
+
"name": "zg-column",
|
|
87
|
+
"description": "The `<zg-column>` tag is used to associate the columns of the grid to the values \nin a dataset. Attributes on the tag are used to configure both the data type, style, and function \nof the grid column. It is possible to build grids without explicit `<zg-column>` tags, and in that \ncase ZingGrid will add a column for each index in the dataset. However, developers are encouraged to \nexplore the features available with `<zg-column>` to utilize the powerful features ZingGrid has to offer.",
|
|
88
|
+
"allowedChildren": [
|
|
89
|
+
"zg-button",
|
|
90
|
+
"zg-checkbox",
|
|
91
|
+
"zg-icon",
|
|
92
|
+
"zg-input",
|
|
93
|
+
"zg-select",
|
|
94
|
+
"zg-text"
|
|
95
|
+
],
|
|
96
|
+
"requiredChildren": [],
|
|
97
|
+
"requiredAttributes": []
|
|
98
|
+
},
|
|
99
|
+
{
|
|
100
|
+
"name": "zg-column-resize",
|
|
101
|
+
"description": "The column resize handle appears when hovering over header to\nresize the column.",
|
|
102
|
+
"allowedChildren": [],
|
|
103
|
+
"requiredChildren": [],
|
|
104
|
+
"requiredAttributes": []
|
|
105
|
+
},
|
|
106
|
+
{
|
|
107
|
+
"name": "zg-control-bar",
|
|
108
|
+
"description": "The `<zg-control-bar>` is inserted dynamically by the ZingGrid library\nand serves as a container for the grid's interface controls. As a generated element, developers\nshould not manually place `<zg-control-bar>` in their grid; however, they may style the bar and\nits internal elements using CSS.",
|
|
109
|
+
"allowedChildren": [],
|
|
110
|
+
"requiredChildren": [],
|
|
111
|
+
"requiredAttributes": []
|
|
112
|
+
},
|
|
113
|
+
{
|
|
114
|
+
"name": "zg-data",
|
|
115
|
+
"description": "The `<zg-data>` tag is used to associate a dataset with the actual grid. \nA top-level attribute is placed on `<zing-grid>` for basic cases, but when more fine grain \ncontrol is required, `<zg-data>`should be employed and various configuration values set via the \n`options` attribute, or more appropriately via `<zg-param>` tags nested within the tag.",
|
|
116
|
+
"allowedChildren": [
|
|
117
|
+
"zg-param"
|
|
118
|
+
],
|
|
119
|
+
"requiredChildren": [],
|
|
120
|
+
"requiredAttributes": []
|
|
121
|
+
},
|
|
122
|
+
{
|
|
123
|
+
"name": "zg-dialog",
|
|
124
|
+
"description": "The `<zg-dialog>` tag is used internally for dialogs used by \nCRUD (Create, Read, Update, and Delete) actions, as well as to\nallow for custom dialogs to be created for generic use with the grid. The design goal of the\ncustom element is to extend HTML's `<dialog>` element for a consistent style and more data grid-\nrelated duties.",
|
|
125
|
+
"allowedChildren": [
|
|
126
|
+
"zg-button",
|
|
127
|
+
"zg-checkbox",
|
|
128
|
+
"zg-icon",
|
|
129
|
+
"zg-input",
|
|
130
|
+
"zg-select",
|
|
131
|
+
"zg-text"
|
|
132
|
+
],
|
|
133
|
+
"requiredChildren": [],
|
|
134
|
+
"requiredAttributes": []
|
|
135
|
+
},
|
|
136
|
+
{
|
|
137
|
+
"name": "zg-editor-row",
|
|
138
|
+
"description": "`<zg-editor-row>` holds the details of the edit mode for the grid.\n`<zg-editor-row>` is created internally and should not be placed directly in the user's HTML.",
|
|
139
|
+
"allowedChildren": [],
|
|
140
|
+
"requiredChildren": [],
|
|
141
|
+
"requiredAttributes": []
|
|
142
|
+
},
|
|
143
|
+
{
|
|
144
|
+
"name": "zg-filter",
|
|
145
|
+
"description": "`<zg-filter>` is the container for a single cell when the cell contains a filter.\n`<zg-filter>` is created internally and should not be placed directly in the user's HTML; however,\nthe user can style the `<zg-filter>` using the `zg-filter` selector.",
|
|
146
|
+
"allowedChildren": [],
|
|
147
|
+
"requiredChildren": [],
|
|
148
|
+
"requiredAttributes": []
|
|
149
|
+
},
|
|
150
|
+
{
|
|
151
|
+
"name": "zg-filter-menu",
|
|
152
|
+
"description": "The `<zg-filter-menu>` element is a container for the menu that appears when clicking the column filter button. \nThe element is dynamically inserted by the library.\nThe element can be styled using CSS.",
|
|
153
|
+
"allowedChildren": [],
|
|
154
|
+
"requiredChildren": [],
|
|
155
|
+
"requiredAttributes": []
|
|
156
|
+
},
|
|
157
|
+
{
|
|
158
|
+
"name": "zg-focus",
|
|
159
|
+
"description": "The `<zg-focus>` element is a generated element added to `<zing-grid>`\nwhen the `selector` attribute is defined. It is used as a container for the focus of cell(s) \nand used as a CSS target for styling by the developer. It should not be accessed specifically\nbeyond styling.",
|
|
160
|
+
"allowedChildren": [],
|
|
161
|
+
"requiredChildren": [],
|
|
162
|
+
"requiredAttributes": []
|
|
163
|
+
},
|
|
164
|
+
{
|
|
165
|
+
"name": "zg-foot",
|
|
166
|
+
"description": "The `<zg-foot>` tag contains the foot cells (`<zg-foot-cell>`) of the data \ngrid specified via the `foot-cell` attribute found on `<zg-column>` tags. The tag roughly\ncorresponds to the idea of the `<tfoot>` tag used in HTML tables. The `<zg-foot>` tag is \ngenerated by the library and should not be placed in a grid manually by a developer, but\ninstead is used as a styling target for CSS.",
|
|
167
|
+
"allowedChildren": [],
|
|
168
|
+
"requiredChildren": [],
|
|
169
|
+
"requiredAttributes": []
|
|
170
|
+
},
|
|
171
|
+
{
|
|
172
|
+
"name": "zg-footer",
|
|
173
|
+
"description": "The `<zg-footer>` cell is a simple container element for content placed at the bottom of a grid. \nIt may contain `<zg-caption>` or `<zg-source>`, but also may contain arbitrarily defined elements inserted by the \ndeveloper. The element and its contents are stylable directly using CSS.",
|
|
174
|
+
"allowedChildren": [
|
|
175
|
+
"zg-button",
|
|
176
|
+
"zg-caption",
|
|
177
|
+
"zg-checkbox",
|
|
178
|
+
"zg-icon",
|
|
179
|
+
"zg-input",
|
|
180
|
+
"zg-select",
|
|
181
|
+
"zg-source",
|
|
182
|
+
"zg-text"
|
|
183
|
+
],
|
|
184
|
+
"requiredChildren": [],
|
|
185
|
+
"requiredAttributes": []
|
|
186
|
+
},
|
|
187
|
+
{
|
|
188
|
+
"name": "zg-frozen-colgroup",
|
|
189
|
+
"description": "The `<zg-frozen-colgroup>` element is used to define the frozen columns. \n`<zg-frozen-colgroup>` is created internally and should not be placed directly in the user's HTML; however,\nthe user can style the `<zg-frozen-colgroup>` using the `zg-frozen-colgroup` selector.",
|
|
190
|
+
"allowedChildren": [],
|
|
191
|
+
"requiredChildren": [],
|
|
192
|
+
"requiredAttributes": []
|
|
193
|
+
},
|
|
194
|
+
{
|
|
195
|
+
"name": "zg-head",
|
|
196
|
+
"description": "The `<zg-head>` tag contains the head cells (`<zg-head-cell>`) of the data grid specified via the\n`head-cell` attribute found on `<zg-column>` tags. The tag roughly corresponds to the idea of the `<thead>` tag used in\nHTML tables. The `<zg-head>` tag is generated by the library and should not be placed in a grid manually by a developer. Instead, it is used as a styling target for CSS.",
|
|
197
|
+
"allowedChildren": [],
|
|
198
|
+
"requiredChildren": [],
|
|
199
|
+
"requiredAttributes": []
|
|
200
|
+
},
|
|
201
|
+
{
|
|
202
|
+
"name": "zg-head-cell",
|
|
203
|
+
"description": "The `<zg-head-cell>` contains header information for a column and is roughly equivalent to the `<th>` \ntag used for HTML tables. The `<zg-head-cell>` tag is generated by the library and should not be placed in a grid \nmanually by a developer. It can be used as a styling target for CSS.",
|
|
204
|
+
"allowedChildren": [],
|
|
205
|
+
"requiredChildren": [],
|
|
206
|
+
"requiredAttributes": []
|
|
207
|
+
},
|
|
208
|
+
{
|
|
209
|
+
"name": "zg-header",
|
|
210
|
+
"description": "`<zg-header>` is the semantic container placed at the top of the grid\nto hold various grid items. `<zg-header>` is created internally and should not be placed\ndirectly in the user's HTML. The element can be styled via CSS.",
|
|
211
|
+
"allowedChildren": [],
|
|
212
|
+
"requiredChildren": [],
|
|
213
|
+
"requiredAttributes": []
|
|
214
|
+
},
|
|
215
|
+
{
|
|
216
|
+
"name": "zg-icon",
|
|
217
|
+
"description": "`<zg-icon>` is used to display custom ZingGrid icons within the grid. \nThe icon is set by its name, but can have a different look based on the grid's theme. \n`<zg-icon>` is created internally when a feature that uses it is enabled, like `pager`, \nbut can be included in the grid manually as long as the name attribute exists.",
|
|
218
|
+
"allowedChildren": [],
|
|
219
|
+
"requiredChildren": [],
|
|
220
|
+
"requiredAttributes": []
|
|
221
|
+
},
|
|
222
|
+
{
|
|
223
|
+
"name": "zg-input",
|
|
224
|
+
"description": "`<zg-input>` contains input fields with added ZingGrid-specific functionality.\nThe specific functionality can be set via the `action` attribute.",
|
|
225
|
+
"allowedChildren": [],
|
|
226
|
+
"requiredChildren": [],
|
|
227
|
+
"requiredAttributes": []
|
|
228
|
+
},
|
|
229
|
+
{
|
|
230
|
+
"name": "zg-layout-controls",
|
|
231
|
+
"description": "Allows you to switch between normal row mode and condensed card mode for the grid. \n`<zg-layout-controls>` is created internally and should not be placed directly in the user's HTML; however,\nthe user can style the `<zg-layout-controls>` using the `zg-layout-controls` selector.",
|
|
232
|
+
"allowedChildren": [],
|
|
233
|
+
"requiredChildren": [],
|
|
234
|
+
"requiredAttributes": []
|
|
235
|
+
},
|
|
236
|
+
{
|
|
237
|
+
"name": "zg-load-mask",
|
|
238
|
+
"description": "The `<zg-load-mask>` element is used to define the loading overlay that displays\non top of the grid before the grid is completely rendered. The element is generally dynamically created, \nthough it is possible to manually define it for a complex loading screen. Define a simple message and use CSS to style the element.",
|
|
239
|
+
"allowedChildren": [
|
|
240
|
+
"zg-button",
|
|
241
|
+
"zg-checkbox",
|
|
242
|
+
"zg-icon",
|
|
243
|
+
"zg-input",
|
|
244
|
+
"zg-select",
|
|
245
|
+
"zg-text"
|
|
246
|
+
],
|
|
247
|
+
"requiredChildren": [],
|
|
248
|
+
"requiredAttributes": []
|
|
249
|
+
},
|
|
250
|
+
{
|
|
251
|
+
"name": "zg-menu",
|
|
252
|
+
"description": "The `<zg-menu>` element is a container for a custom menu for ZingGrid \nused as a context or static (aka \"Hamburger\") menu. The element is generally dynamically \ninserted by the library, though the developer can append of overwrite menu with custom \nentries. The element can be styled using CSS.",
|
|
253
|
+
"allowedChildren": [
|
|
254
|
+
"zg-button",
|
|
255
|
+
"zg-checkbox",
|
|
256
|
+
"zg-icon",
|
|
257
|
+
"zg-input",
|
|
258
|
+
"zg-menu-group",
|
|
259
|
+
"zg-menu-item",
|
|
260
|
+
"zg-select",
|
|
261
|
+
"zg-text"
|
|
262
|
+
],
|
|
263
|
+
"requiredChildren": [],
|
|
264
|
+
"requiredAttributes": []
|
|
265
|
+
},
|
|
266
|
+
{
|
|
267
|
+
"name": "zg-menu-group",
|
|
268
|
+
"description": "A group wrapper for multiple menu items found in the context \nmenu. ZingGrid dynamically creates this element to hold various `<zg-menu-item>` \ntags together for organizational purposes. As it is a visual element, it can be \nstyled via CSS.",
|
|
269
|
+
"allowedChildren": [
|
|
270
|
+
"zg-menu-item"
|
|
271
|
+
],
|
|
272
|
+
"requiredChildren": [],
|
|
273
|
+
"requiredAttributes": []
|
|
274
|
+
},
|
|
275
|
+
{
|
|
276
|
+
"name": "zg-menu-item",
|
|
277
|
+
"description": "This element defines a single menu item in ZingGrid's context \nmenu defined by `<zg-menu>`. The element is typically dynamically generated, though \nit can be overwritten by a user's own custom `<zg-menu-item>` elements. The \nelement can be styled via CSS.",
|
|
278
|
+
"allowedChildren": [],
|
|
279
|
+
"requiredChildren": [],
|
|
280
|
+
"requiredAttributes": []
|
|
281
|
+
},
|
|
282
|
+
{
|
|
283
|
+
"name": "zg-no-data",
|
|
284
|
+
"description": "`<zg-no-data>` is used to display a message when there are no records. The \nelement internally wraps any text in a `<div role=\"any\">` tag. The\nelement is stylable with CSS like most ZingGrid elements.",
|
|
285
|
+
"allowedChildren": [
|
|
286
|
+
"zg-button",
|
|
287
|
+
"zg-checkbox",
|
|
288
|
+
"zg-icon",
|
|
289
|
+
"zg-input",
|
|
290
|
+
"zg-select",
|
|
291
|
+
"zg-text"
|
|
292
|
+
],
|
|
293
|
+
"requiredChildren": [],
|
|
294
|
+
"requiredAttributes": []
|
|
295
|
+
},
|
|
296
|
+
{
|
|
297
|
+
"name": "zg-option-list",
|
|
298
|
+
"description": "An option's list to go within a `<zg-select>` element",
|
|
299
|
+
"allowedChildren": [],
|
|
300
|
+
"requiredChildren": [],
|
|
301
|
+
"requiredAttributes": []
|
|
302
|
+
},
|
|
303
|
+
{
|
|
304
|
+
"name": "zg-pager",
|
|
305
|
+
"description": "An element that contains the UI controls for paging through a grid's dataset. The \nelement can be manually placed, though it is more often dynamically inserted when paging is enabled via \nthe `pager` attribute on the `<zing-grid>` tag. The element can be styled via CSS.",
|
|
306
|
+
"allowedChildren": [
|
|
307
|
+
"zg-button",
|
|
308
|
+
"zg-checkbox",
|
|
309
|
+
"zg-icon",
|
|
310
|
+
"zg-input",
|
|
311
|
+
"zg-select",
|
|
312
|
+
"zg-text"
|
|
313
|
+
],
|
|
314
|
+
"requiredChildren": [],
|
|
315
|
+
"requiredAttributes": []
|
|
316
|
+
},
|
|
317
|
+
{
|
|
318
|
+
"name": "zg-param",
|
|
319
|
+
"description": "`<zg-param>` is a non-visual element used to pass the configuration options for the `<zg-data>` \nelement more cleanly via `name`-`value` pairs. The element is not required, though it is preferred, as everything set \nwithin a `<zg-param>` element can also be set directly on `<zg-data>` via the `config` attribute. Developers should note \nthat when setting complex values for the `value` attribute to use JSON encoded values. Also, as a non-visual element, \nCSS styling does not apply to `<zg-param>`.",
|
|
320
|
+
"allowedChildren": [],
|
|
321
|
+
"requiredChildren": [],
|
|
322
|
+
"requiredAttributes": []
|
|
323
|
+
},
|
|
324
|
+
{
|
|
325
|
+
"name": "zg-row",
|
|
326
|
+
"description": "`<zg-row>` is the container for the `<zg-cell>`, `<zg-head-cell>`, and `<zg-filter>` elements.\nIt corresponds to the `<tr>` tag on an HTML table.\nThe `<zg-row>` element is created dynamically and should not be placed in the grid by a developer. \nHowever, the element is useful for styling the various rows of the grid using CSS.",
|
|
327
|
+
"allowedChildren": [],
|
|
328
|
+
"requiredChildren": [],
|
|
329
|
+
"requiredAttributes": []
|
|
330
|
+
},
|
|
331
|
+
{
|
|
332
|
+
"name": "zg-row-details",
|
|
333
|
+
"description": "`<zg-row-details>` is the container for a row expansion;",
|
|
334
|
+
"allowedChildren": [
|
|
335
|
+
"zing-grid"
|
|
336
|
+
],
|
|
337
|
+
"requiredChildren": [],
|
|
338
|
+
"requiredAttributes": []
|
|
339
|
+
},
|
|
340
|
+
{
|
|
341
|
+
"name": "zg-search",
|
|
342
|
+
"description": "The `<zg-search>` element is used to encapsulate the interface widget necessary for searching the grid -- \ntypically a text field and a button to trigger the search. The element is added dynamically when search is specified and \nshould not be directly inserted by the developer. The element and its contents can be styled using CSS.",
|
|
343
|
+
"allowedChildren": [],
|
|
344
|
+
"requiredChildren": [],
|
|
345
|
+
"requiredAttributes": []
|
|
346
|
+
},
|
|
347
|
+
{
|
|
348
|
+
"name": "zg-select",
|
|
349
|
+
"description": "A custom select dropdown defined by our library. The\ndropdown can be assigned different options through the `options` attribute.",
|
|
350
|
+
"allowedChildren": [],
|
|
351
|
+
"requiredChildren": [],
|
|
352
|
+
"requiredAttributes": []
|
|
353
|
+
},
|
|
354
|
+
{
|
|
355
|
+
"name": "zg-selector-mask",
|
|
356
|
+
"description": "`<zg-selector-mask>` is used to wrap the cells during user selection for \nstyling purposes. The element is dynamically added to the grid based upon the presence of the \n`selector` attribute on the `<zing-grid>` element. The element should not be manually inserted, \nthough it can be styled using CSS.",
|
|
357
|
+
"allowedChildren": [],
|
|
358
|
+
"requiredChildren": [],
|
|
359
|
+
"requiredAttributes": []
|
|
360
|
+
},
|
|
361
|
+
{
|
|
362
|
+
"name": "zg-separator",
|
|
363
|
+
"description": "`<zg-separator>` specifies the horizontal bar in the `<zg-menu>` used for separating \nitems. The element is created dynamically and should not be manually inserted by developers. However,\n`<zg-separator>` can be styled using CSS.",
|
|
364
|
+
"allowedChildren": [],
|
|
365
|
+
"requiredChildren": [],
|
|
366
|
+
"requiredAttributes": []
|
|
367
|
+
},
|
|
368
|
+
{
|
|
369
|
+
"name": "zg-source",
|
|
370
|
+
"description": "`<zg-source>` is used to source the data in ZingGrid. The \nelement internally wraps any text in a `<cite role=\"generic\">` tag for proper semantics. The\nelement is stylable with CSS like most ZingGrid elements.",
|
|
371
|
+
"allowedChildren": [
|
|
372
|
+
"zg-button",
|
|
373
|
+
"zg-checkbox",
|
|
374
|
+
"zg-icon",
|
|
375
|
+
"zg-input",
|
|
376
|
+
"zg-select",
|
|
377
|
+
"zg-text"
|
|
378
|
+
],
|
|
379
|
+
"requiredChildren": [],
|
|
380
|
+
"requiredAttributes": []
|
|
381
|
+
},
|
|
382
|
+
{
|
|
383
|
+
"name": "zg-status",
|
|
384
|
+
"description": "`<zg-status>` is a custom element used to display messages to the \nuser, such as errors and verifications of CRUD actions. `<zg-status>` is created \ndynamically and should not be inserted manually. The `<zg-status>` element is \nstylable with CSS.",
|
|
385
|
+
"allowedChildren": [],
|
|
386
|
+
"requiredChildren": [],
|
|
387
|
+
"requiredAttributes": []
|
|
388
|
+
},
|
|
389
|
+
{
|
|
390
|
+
"name": "zg-table",
|
|
391
|
+
"description": "The `<zg-table>` component replicates the `<table>` functionality in the grid.\nIt contains `<zg-head>`, `<zg-body>`, `<zg-foot>`, and `<zg-colgroup>`. \nThe element and its contents are stylable directly using CSS.",
|
|
392
|
+
"allowedChildren": [],
|
|
393
|
+
"requiredChildren": [],
|
|
394
|
+
"requiredAttributes": []
|
|
395
|
+
},
|
|
396
|
+
{
|
|
397
|
+
"name": "zg-text",
|
|
398
|
+
"description": "`<zg-text>` is a ZingGrid specific text value that is bound to \nthe status of the grid, as defined by the `value` attribute. The field can be \nmanually inserted by a developer, but is more commonly added by the use of certain \ngrid features, like paging. The element is stylable with CSS.",
|
|
399
|
+
"allowedChildren": [],
|
|
400
|
+
"requiredChildren": [],
|
|
401
|
+
"requiredAttributes": []
|
|
402
|
+
},
|
|
403
|
+
{
|
|
404
|
+
"name": "zg-tooltip",
|
|
405
|
+
"description": "`<zg-tooltip>` elements are inserted dynamically by the ZingGrid library\nand serves as a container for the grid's tooltips. As a generated element, developers\nshould not manually place `<zg-tooltip>` in their grid; however, they may style the tooltips and\nits internal elements using CSS.",
|
|
406
|
+
"allowedChildren": [],
|
|
407
|
+
"requiredChildren": [],
|
|
408
|
+
"requiredAttributes": []
|
|
409
|
+
},
|
|
410
|
+
{
|
|
411
|
+
"name": "zing-grid",
|
|
412
|
+
"description": "The most important tag in the library. Contains most of the attributes to turn grid features on/off. \nSet `zing-grid:not(:defined) {display:none;}` to hide <zing-grid> instances until they are ready. \nThis stops child elements from appearing unstyled for a brief moment.",
|
|
413
|
+
"allowedChildren": [
|
|
414
|
+
"zg-caption",
|
|
415
|
+
"zg-card",
|
|
416
|
+
"zg-colgroup",
|
|
417
|
+
"zg-data",
|
|
418
|
+
"zg-dialog",
|
|
419
|
+
"zg-footer",
|
|
420
|
+
"zg-load-mask",
|
|
421
|
+
"zg-menu",
|
|
422
|
+
"zg-pager"
|
|
423
|
+
],
|
|
424
|
+
"requiredChildren": [],
|
|
425
|
+
"requiredAttributes": []
|
|
426
|
+
}
|
|
427
|
+
]
|
|
428
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "zinggrid-metadata",
|
|
3
|
-
"version": "1.0.
|
|
3
|
+
"version": "1.0.1",
|
|
4
4
|
"zinggridVersion": "2.1.5",
|
|
5
5
|
"description": "Capabilities metadata and features registry for ZingGrid.",
|
|
6
6
|
"keywords": [
|
|
@@ -8,11 +8,14 @@
|
|
|
8
8
|
"custom-elements",
|
|
9
9
|
"capabilities-metadata",
|
|
10
10
|
"features-registry",
|
|
11
|
+
"content-model-schema",
|
|
12
|
+
"cms",
|
|
11
13
|
"metadata",
|
|
12
14
|
"web-components"
|
|
13
15
|
],
|
|
14
16
|
"files": [
|
|
15
17
|
"capabilities-metadata.json",
|
|
18
|
+
"content-model-schema.json",
|
|
16
19
|
"features-registry.json"
|
|
17
20
|
],
|
|
18
21
|
"repository": {
|