The tags field is perfect for multiple variable options, which should be stored in a single field. It comes with built-in autocompletion for options and an intuitive interface for adding and removing multiple tags.
||If set to
|api||–||API settings for options requests. This will only take affect when
||–||Sets the focus on this field when the form loads. Only the first field with this label gets|
|default||–||Default value for the field, which will be used when a page/file/user is created|
|help||–||Optional help text below the field|
||Changes the tag icon|
|label||–||The field label can be set as string or associative array with translations|
||–||Maximum number of allowed entries/tags|
||–||Minimum number of required entries/tags|
||An array with options|
|query||–||Query settings for options queries. This will only take affect when
||Custom tags separator, which will be used to store tags in the content file|
|when||–||Conditions when the field will be shown (since 3.1.0)|
||The width of the field in the field grid. Available widths:
For autocompletion to work, you need to set the
options attribute. Options can be a fixed list (see below) or dynamic options using the query option.
You can also define different
text for options:
Our options query syntax offers a very powerful way of converting pages, files, users, page values and even items in structure fields into automatically generated option lists.
The example above will turn all published main pages of the site into options. The title of each page will be used as the text of the option and the page id will be used as the stored value.
You can start at the
users collection or the
kirby instance to run your query. The result must be a collection of
users or a structure object
You can use array syntax and nested queries in Kirby's query syntax.
To customize the displayed text or the stored value, you can be more specific when defining the query: The
query option gets three suboptions, where
fetch takes over the options query.
value can be defined with the help of our string template language to get exactly what you want as the result.
As in the example above, all custom fields of a page can be accessed. You can even combine fields and use field methods:
If you want to store numeric keys as values, you have to use the long notation with
With a query it is not only possible to fetch options from pages, users, files or structure fields. You can also split comma-separated values of fields such as tags or checkboxes in order to create options from the result array.
Of course you get the same flexibility with those array values, to modify the result text and stored value. Each item in the array will automatically be converted into an object with a
value property. Those properties are regular Kirby content fields and you can use all field methods to work with them further. Items in the array need to be referenced as
If the values in a field are separated by something other than a comma, you can of course specify this as well in the query.
To fetch options from a structure field, you can use the
toStructure method and then fetch the text and value from the fields of the structure items:
Assuming we have a structure field like this:
We can fetch the fields by using the keyword
If the option queries are not enough or you need to pluck an external source for option data, you can use the API setting.
By default, the API setting expects that the JSON endpoint returns an option array as shown above in the manual option setting.
You can be much more specific with the endpoint though and describe which kind of data to fetch and what to convert to text and value - pretty much as with the option queries.
Let's assume that our JSON endpoint returns the following JSON:
As you can see, the format doesn't follow our expected option format at all. We first need to go down to the companies property and then somehow convert each company object into text and value for the options.
This can be done with our template language:
fetch attribute we can define where to start in the JSON document. This can even go down nested structures or sort entries:
The JSON document is turned into a Kirby structure and thus can be queried and manipulated just like any other data within Kirby.
Afterwards the text and value setting can be modified by defining the template for each item.
Again, each item is being converted to a Kirby object and every property of the object is a typical Kirby field with all the available field methods. We can go pretty wild with this, if we want. Let's just assume we have a little bit more data for each company …
This would produce the following PHP array of options:
Instead of hard-coding an absolute URL into your blueprint, it's often better to have more control over the API URL. Especially when you are working with different environments (ie. local, staging, production)
The URL option of the API setup can also be modified by using the string template language:
With this simple addition, the API URL will always refer to the main URL of the site. You can also access the configuration instead to get even more flexibility
accept property, you can limit tag input to the query options:
Tags can also be shown as a list using the
A tags field stores all selected values in a comma separated list (
value1, value2, value3) You can split this list with the
split() method in your templates and then work with the result:
If you use another separator than the default comma, you have to pass this separator to the
split() method, for example when using
| as separator:
$field->split() for more information.