├── .github
    └── workflows
    │   └── main.yaml
├── CHANGELOG.md
├── LICENSE
├── README.md
├── composer.json
└── src
    ├── Element.php
    ├── ElementInterface.php
    ├── ElementTrait.php
    ├── SelfClosingElement.php
    ├── StringElement.php
    └── functions.php


/.github/workflows/main.yaml:
--------------------------------------------------------------------------------
 1 | name: "testing"
 2 | 
 3 | on:
 4 |     push:
 5 |         branches: [ master ]
 6 |     pull_request:
 7 |         branches: [ master ]
 8 | 
 9 | jobs:
10 |     qa:
11 |         name: Quality assurance
12 |         runs-on: ubuntu-latest
13 | 
14 |         steps:
15 |             - name: Checkout
16 |               uses: actions/checkout@v4
17 | 
18 |             - name: Validate composer.json and composer.lock
19 |               run: composer validate
20 | 
21 |             - name: Cache Composer packages
22 |               id: composer-cache
23 |               uses: actions/cache@v4
24 |               with:
25 |                   path: vendor
26 |                   key: ${{ runner.os }}-php-${{ hashFiles('**/composer.lock') }}
27 |                   restore-keys: |
28 |                       ${{ runner.os }}-php-
29 | 
30 |             - name: Install dependencies
31 |               if: steps.composer-cache.outputs.cache-hit != 'true'
32 |               run: composer install --prefer-dist --no-progress
33 | 
34 |             - name: Coding Standard
35 |               run: composer run-script cs
36 | 
37 |     tests:
38 |         name: Tests
39 |         runs-on: ubuntu-latest
40 | 
41 |         strategy:
42 |             matrix:
43 |                 php:
44 |                     - 7.2
45 |                     - 7.3
46 |                     - 7.4
47 |                     - 8.0
48 |                     - 8.1
49 |                     - 8.2
50 |                     - 8.3
51 |                     - 8.4
52 | 
53 |         steps:
54 |             - name: Checkout
55 |               uses: actions/checkout@v4
56 | 
57 |             - name: Install PHP
58 |               uses: shivammathur/setup-php@v2
59 |               with:
60 |                   php-version: ${{ matrix.php }}
61 | 
62 |             - name: Cache PHP dependencies
63 |               uses: actions/cache@v4
64 |               with:
65 |                   path: vendor
66 |                   key: ${{ runner.os }}-php-${{ matrix.php }}-composer-${{ hashFiles('**/composer.json') }}
67 |                   restore-keys: ${{ runner.os }}-php-${{ matrix.php }}-composer-
68 | 
69 |             - name: Install dependencies
70 |               run: composer install --prefer-dist --no-progress
71 | 
72 |             - name: Tests
73 |               run: composer test
74 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | All notable changes to this project will be documented in this file.
 4 | 
 5 | The format is based on [Keep a Changelog](http://keepachangelog.com/)
 6 | and this project adheres to [Semantic Versioning](http://semver.org/).
 7 | 
 8 | ## [1.0.0] - 2025-03-27
 9 | ### Added
10 | - Support for PHP 8.4 and development improvements.
11 | 
12 | ## [0.1.5] - 2019-12-05
13 | ### Added
14 | - New `raw()` function to add raw unescaped html.
15 | 
16 | ## [0.1.4] - 2019-12-01
17 | ### Fixed
18 | - The elements `area`, `track`, `embed`, `param`, `source` and `col` are [empty elements](https://developer.mozilla.org/en-US/docs/Glossary/empty_element) so they should use the `SelfClosingElement` class.
19 | - Code style improvements
20 | 
21 | ## [0.1.3] - 2019-06-15
22 | ### Fixed
23 | - Fixed `<style>` and `<script>` elements that should not escape the strings.
24 | 
25 | ## [0.1.2] - 2019-05-04
26 | ### Fixed
27 | - Fixed a bug on create a self closing element with an array of attributes: `input(['type' => 'text'])`.
28 | 
29 | ## [0.1.1] - 2019-05-02
30 | ### Fixed
31 | - Add support for `null` values as children
32 | - Escape special characters to HTML entities using [htmlspecialchars](https://php.net/htmlspecialchars)
33 | 
34 | ## 0.1.0 - 2019-04-27
35 | First version
36 | 
37 | [1.0.0]: https://github.com/oscarotero/html/compare/v0.1.5..v1.0.0
38 | [0.1.5]: https://github.com/oscarotero/html/compare/v0.1.4...v0.1.5
39 | [0.1.4]: https://github.com/oscarotero/html/compare/v0.1.3...v0.1.4
40 | [0.1.3]: https://github.com/oscarotero/html/compare/v0.1.2...v0.1.3
41 | [0.1.2]: https://github.com/oscarotero/html/compare/v0.1.1...v0.1.2
42 | [0.1.1]: https://github.com/oscarotero/html/compare/v0.1.0...v0.1.1
43 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Oscar Otero
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # html
  2 | PHP library to generate HTML code
  3 | 
  4 | ## Install
  5 | 
  6 | Note, PHP ~7.2 is required
  7 | 
  8 | ```sh
  9 | composer require oscarotero/html
 10 | ```
 11 | 
 12 | ## Usage
 13 | 
 14 | ```php
 15 | namespace Html;
 16 | 
 17 | //Create a div
 18 | $div = div();
 19 | 
 20 | //Render the div
 21 | echo $div;
 22 | //<div></div>
 23 | 
 24 | //Create a div with text content
 25 | echo div('Hello world');
 26 | //<div>Hello world</div>
 27 | 
 28 | //Create a div with more text content
 29 | echo div('Hello', ' world');
 30 | //<div>Hello world</div>
 31 | 
 32 | //HTML entities are escaped
 33 | echo div('Hello', ' <world>');
 34 | //<div>Hello &lt;world&gt;</div>
 35 | 
 36 | //Use the function raw() to do not escape html entities
 37 | echo div('Hello', raw(' <world>'));
 38 | //<div>Hello <world></div>
 39 | 
 40 | //Create a div with html content
 41 | echo div('Hello ', strong('world'));
 42 | //<div>Hello <strong>world</strong></div>
 43 | 
 44 | //A div with many content
 45 | echo div(
 46 |     h1('Hello world'),
 47 |     p('This is a paragraph'),
 48 |     ul(
 49 |         li('And this is a list item'),
 50 |         li('Other list item')
 51 |     )
 52 | );
 53 | ```
 54 | 
 55 | ## Attributes
 56 | 
 57 | There are two ways to add attributes to the html tags: using an array as the first argument or using magic methods.
 58 | 
 59 | ```php
 60 | //Add attributes using an array
 61 | echo div(['id' => 'foo'], 'Hello world');
 62 | 
 63 | //Or add attributes with magic methods
 64 | echo div('Hello world')->id('foo');
 65 | 
 66 | //Both examples outputs: <div id="foo">Hello world</div>
 67 | ```
 68 | 
 69 | All attributes with `null` as value are omitted:
 70 | 
 71 | ```php
 72 | //Add attributes using an array
 73 | echo div(['id' => null], 'Hello world');
 74 | 
 75 | //Or add attributes with magic methods
 76 | echo div('Hello world')->id(null);
 77 | 
 78 | //Both examples outputs: <div>Hello world</div>
 79 | ```
 80 | 
 81 | ### Flags
 82 | 
 83 | In HTML, flags (or boolean attributes) are attributes that does not need a value. Use `boolean` values to add flags.
 84 | 
 85 | Example using array syntax:
 86 | 
 87 | ```php
 88 | //Positive flag 
 89 | echo div(['hidden' => true]);
 90 | //<div hidden></div>
 91 | 
 92 | //Negative flag 
 93 | echo div(['hidden' => false]);
 94 | //<div></div>
 95 | 
 96 | //A short method to add positive flags:
 97 | echo div(['hidden']);
 98 | //<div hidden></div>
 99 | 
100 | //Mixing attributes and flags
101 | echo div(['hidden', 'class' => 'foo']);
102 | //<div hidden class="foo"></div>
103 | ```
104 | 
105 | Example using magic methods:
106 | ```php
107 | //Positive flag 
108 | echo div()->hidden(true);
109 | //<div hidden></div>
110 | 
111 | //Negative flag 
112 | echo div()->hidden(false);
113 | //<div></div>
114 | 
115 | //A short method to add positive flags (true is not needed):
116 | echo div()->hidden();
117 | //<div hidden></div>
118 | ```
119 | 
120 | ### Classes
121 | 
122 | Some attributes can contain several space-separated values, for example `class`. You can use an array to add classes:
123 | 
124 | ```php
125 | //Using an array
126 | echo div(['class' => ['foo', 'bar']]);
127 | 
128 | //Using the magic method:
129 | echo div()->class(['foo', 'bar']);
130 | 
131 | //Both examples return: <div class="foo bar"></div>
132 | ```
133 | 
134 | Use the `key => value` syntax to add classes under some conditions. Only if the value is evaluated as true, the class will be added:
135 | 
136 | ```php
137 | //Using an array
138 | echo div([
139 |     'class' => [
140 |         'foo',
141 |         'bar',
142 |         'theme-blue' => true,
143 |         'error' => !empty($error)
144 |     ]
145 | ]);
146 | 
147 | //Using the magic method:
148 | echo div()->class([
149 |     'foo',
150 |     'bar',
151 |     'theme-blue' => true,
152 |     'error' => !empty($error)
153 | ]);
154 | 
155 | //Both examples output: <div class="foo bar theme-blue"></div>
156 | ```
157 | 
158 | ### data-* attributes
159 | 
160 | Any `data-*` attribute containing a non-scalable value, will be converted to json. Unlike flags, boolean values are included too:
161 | 
162 | ```php
163 | //Using an array
164 | echo div([
165 |     'data-enabled' => true,
166 |     'data-other' => false,
167 |     'data-omitted' => null, //Null values are ommitted
168 |     'data-options' => ['foo', 'bar']
169 | ]);
170 | 
171 | //Using the special method `data()`
172 | echo div()
173 |     ->data('enabled', true),
174 |     ->data('other', false),
175 |     ->data('omitted', null),
176 |     ->data('options', ['foo', 'bar']);
177 | 
178 | //Both examples output: <div data-enabled="true" data-other="false" data-options="[&quot;foo&quot;,&quot;bar&quot;]"></div>
179 | ```
180 | 
181 | ## Import/Export
182 | 
183 | Elements implements `JsonSerializable` and `Serializable` interfaces, so you can export them:
184 | 
185 | ```php
186 | $article = article(
187 |     header(
188 |         h1('Hello world')
189 |     ),
190 |     div(['class' => 'content'],
191 |         p('This is an article')
192 |     )
193 | );
194 | 
195 | //Export to JSON
196 | $json = json_encode($article);
197 | 
198 | //Use the function array2Html to recreate the html from json:
199 | $article = array2Html(json_decode($json, true));
200 | 
201 | //Serialize and unserialize
202 | $ser = serialize($article);
203 | $article = unserialize($ser);
204 | ```
205 | 
206 | ## Other interfaces implemented
207 | 
208 | All elements that can contain children (not self-closing elements like `<br>` or `<img>`) implement the following standard PHP interfaces:
209 | 
210 | ### ArrayAccess
211 | 
212 | To access to the children elements using the array API.
213 | 
214 | ```php
215 | $div = div('First child', strong('Second child'), 'Third child');
216 | 
217 | echo $div[2]; //Third child
218 | ```
219 | 
220 | ### IteratorAggregate
221 | 
222 | To iterate with the element:
223 | 
224 | ```php
225 | $div = div('First child', strong('Second child'), 'Third child');
226 | 
227 | foreach ($div as $child) {
228 |     echo $child;
229 | }
230 | ```
231 | 
232 | ### Countable
233 | 
234 | To use `count()`:
235 | 
236 | ```php
237 | $div = div('First child', strong('Second child'), 'Third child');
238 | 
239 | echo count($div); //3
240 | ```
241 | 
242 | Note that `NULL` children are discarded
243 | 
244 | ```php
245 | $div = div('First child', null, 'Third child');
246 | 
247 | echo count($div); //2
248 | ```
249 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "oscarotero/html",
 3 |     "type": "library",
 4 |     "description": "HTML generator",
 5 |     "keywords": ["html"],
 6 |     "homepage": "https://github.com/oscarotero/html",
 7 |     "license": "MIT",
 8 |     "authors": [
 9 |         {
10 |             "name": "Oscar Otero",
11 |             "email": "oom@oscarotero.com",
12 |             "homepage": "http://oscarotero.com",
13 |             "role": "Developer"
14 |         }
15 |     ],
16 |     "support": {
17 |         "email": "oom@oscarotero.com",
18 |         "issues": "https://github.com/oscarotero/html/issues"
19 |     },
20 |     "require": {
21 |         "php": ">=7.2"
22 |     },
23 |     "require-dev": {
24 |         "phpunit/phpunit": "^8 || ^9",
25 |         "friendsofphp/php-cs-fixer": "^3",
26 |         "oscarotero/php-cs-fixer-config": "^2"
27 |     },
28 |     "autoload": {
29 |         "psr-4": {
30 |             "Html\\": "src"
31 |         },
32 |         "files": [
33 |             "src/functions.php"
34 |         ]
35 |     },
36 |     "autoload-dev": {
37 |         "psr-4": {
38 |             "Html\\Tests\\": "tests"
39 |         }
40 |     },
41 |     "scripts": {
42 |         "cs": "php-cs-fixer",
43 |         "test": "phpunit",
44 |         "cs-fix": "php-cs-fixer fix"
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Element.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types = 1);
  3 | 
  4 | namespace Html;
  5 | 
  6 | use ArrayAccess;
  7 | use ArrayIterator;
  8 | use Countable;
  9 | use InvalidArgumentException;
 10 | use IteratorAggregate;
 11 | 
 12 | final class Element implements ElementInterface, ArrayAccess, IteratorAggregate, Countable
 13 | {
 14 |     use ElementTrait;
 15 | 
 16 |     public const NO_ESCAPE_STRINGS = 2;
 17 | 
 18 |     private $children = [];
 19 | 
 20 |     public static function create(string $tagName, array $children, int $options = 0)
 21 |     {
 22 |         if (isset($children[0]) && is_array($children[0])) {
 23 |             $attributes = array_shift($children);
 24 | 
 25 |             $element = new static($tagName, $attributes, $options);
 26 |         } else {
 27 |             $element = new static($tagName, [], $options);
 28 |         }
 29 | 
 30 |         if ($children) {
 31 |             return $element->append(...$children);
 32 |         }
 33 | 
 34 |         return $element;
 35 |     }
 36 | 
 37 |     public function __clone()
 38 |     {
 39 |         foreach ($this->children as &$child) {
 40 |             if ($child instanceof ElementInterface) {
 41 |                 $child = clone $child;
 42 |             }
 43 |         }
 44 |     }
 45 | 
 46 |     public function __toString(): string
 47 |     {
 48 |         $content = implode('', $this->children);
 49 | 
 50 |         return sprintf('%s%s</%s>', $this->getOpeningHtml(), $content, $this->tagName);
 51 |     }
 52 | 
 53 |     public function jsonSerialize()
 54 |     {
 55 |         return [
 56 |             'tag' => $this->tagName,
 57 |             'attributes' => $this->attributes,
 58 |             'children' => $this->children,
 59 |         ];
 60 |     }
 61 | 
 62 |     public function serialize()
 63 |     {
 64 |         return serialize($this->jsonSerialize());
 65 |     }
 66 | 
 67 |     public function unserialize($data)
 68 |     {
 69 |         $data = unserialize($data);
 70 | 
 71 |         $this->tagName = $data['tag'];
 72 |         $this->attributes = $data['attributes'];
 73 |         $this->children = $data['children'];
 74 |     }
 75 | 
 76 |     public function append(...$children): self
 77 |     {
 78 |         foreach ($children as $child) {
 79 |             $this->offsetSet(null, $child);
 80 |         }
 81 | 
 82 |         return $this;
 83 |     }
 84 | 
 85 |     public function offsetExists($offset)
 86 |     {
 87 |         return isset($this->children[$offset]);
 88 |     }
 89 | 
 90 |     public function offsetGet($offset)
 91 |     {
 92 |         return $this->children[$offset] ?? null;
 93 |     }
 94 | 
 95 |     public function offsetSet($offset, $value)
 96 |     {
 97 |         if ($value === null) {
 98 |             return;
 99 |         }
100 | 
101 |         if (!\is_scalar($value) && !($value instanceof ElementInterface)) {
102 |             throw new InvalidArgumentException(
103 |                 sprintf('Invalid child. Must be a scalar or an object implementing %s', ElementInterface::class)
104 |             );
105 |         }
106 | 
107 |         if (is_string($value) && !($this->options & self::NO_ESCAPE_STRINGS)) {
108 |             $value = \htmlspecialchars($value, ENT_NOQUOTES);
109 |         }
110 | 
111 |         if ($offset === null) {
112 |             $this->children[] = $value;
113 |         } else {
114 |             $this->children[$offset] = $value;
115 |         }
116 |     }
117 | 
118 |     public function offsetUnset($offset)
119 |     {
120 |         unset($this->children[$offset]);
121 |     }
122 | 
123 |     public function getIterator()
124 |     {
125 |         return new ArrayIterator($this->children);
126 |     }
127 | 
128 |     public function count(): int
129 |     {
130 |         return count($this->children);
131 |     }
132 | }
133 | 


--------------------------------------------------------------------------------
/src/ElementInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace Html;
 5 | 
 6 | use JsonSerializable;
 7 | use Serializable;
 8 | 
 9 | interface ElementInterface extends JsonSerializable, Serializable
10 | {
11 |     public function __call(string $name, array $arguments): ElementInterface;
12 | 
13 |     public function __toString(): string;
14 | 
15 |     public function data(string $key, $value): ElementInterface;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/ElementTrait.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types = 1);
  3 | 
  4 | namespace Html;
  5 | 
  6 | trait ElementTrait
  7 | {
  8 |     private $tagName;
  9 |     private $attributes = [];
 10 |     private $options = 0;
 11 | 
 12 |     public function __construct(string $tagName, array $attributes = [], int $options = 0)
 13 |     {
 14 |         $this->tagName = $tagName;
 15 |         $this->options = $options;
 16 | 
 17 |         foreach ($attributes as $name => $value) {
 18 |             if (is_int($name)) {
 19 |                 $this->__call($value, []);
 20 |             } else {
 21 |                 $this->__call($name, [$value]);
 22 |             }
 23 |         }
 24 |     }
 25 | 
 26 |     public function data(string $key, $value): ElementInterface
 27 |     {
 28 |         return $this->__call("data-{$key}", [$value]);
 29 |     }
 30 | 
 31 |     public function __call(string $name, array $arguments): ElementInterface
 32 |     {
 33 |         $this->attributes[$name] = array_key_exists(0, $arguments) ? $arguments[0] : true;
 34 | 
 35 |         return $this;
 36 |     }
 37 | 
 38 |     private function getOpeningHtml(): string
 39 |     {
 40 |         $attributes = [];
 41 | 
 42 |         foreach ($this->attributes as $name => $value) {
 43 |             $attributes[] = self::stringifyAttribute($name, $value);
 44 |         }
 45 | 
 46 |         $attributes = trim(implode(' ', array_filter($attributes)));
 47 | 
 48 |         return sprintf('<%s%s>', $this->tagName, $attributes === '' ? '' : " {$attributes}");
 49 |     }
 50 | 
 51 |     private static function stringifyAttribute(string $name, $value): string
 52 |     {
 53 |         if (stripos($name, 'data-') === 0) {
 54 |             $value = self::handleDataAttribute($value);
 55 |         } elseif (is_array($value)) {
 56 |             $value = self::handleArrayAttribute($value);
 57 |         }
 58 | 
 59 |         if ($value === false || $value === null) {
 60 |             return '';
 61 |         }
 62 | 
 63 |         if ($value === true) {
 64 |             return $name;
 65 |         }
 66 | 
 67 |         if (is_string($value)) {
 68 |             $value = htmlspecialchars($value, ENT_QUOTES, 'UTF-8');
 69 |         }
 70 | 
 71 |         return sprintf('%s="%s"', $name, $value);
 72 |     }
 73 | 
 74 |     private static function handleDataAttribute($value): ?string
 75 |     {
 76 |         if (is_null($value)) {
 77 |             return null;
 78 |         }
 79 | 
 80 |         if (is_bool($value)) {
 81 |             return json_encode($value);
 82 |         }
 83 | 
 84 |         if (is_scalar($value)) {
 85 |             return (string) $value;
 86 |         }
 87 | 
 88 |         return json_encode($value);
 89 |     }
 90 | 
 91 |     private static function handleArrayAttribute(array $values, string $glue = ' '): ?string
 92 |     {
 93 |         $filtered = [];
 94 | 
 95 |         foreach ($values as $k => $v) {
 96 |             if (is_int($k)) {
 97 |                 if ($v !== '' && $v !== false && $v !== null) {
 98 |                     $filtered[] = $v;
 99 |                 }
100 |                 continue;
101 |             }
102 | 
103 |             if (!empty($v)) {
104 |                 $filtered[] = $k;
105 |             }
106 |         }
107 | 
108 |         if (empty($filtered)) {
109 |             return null;
110 |         }
111 | 
112 |         return implode($glue, $filtered);
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/src/SelfClosingElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace Html;
 5 | 
 6 | final class SelfClosingElement implements ElementInterface
 7 | {
 8 |     use ElementTrait;
 9 | 
10 |     public static function create(string $tagName, array $attributes, int $options = 0)
11 |     {
12 |         return new static($tagName, $attributes[0] ?? [], $options);
13 |     }
14 | 
15 |     public function __toString(): string
16 |     {
17 |         return $this->getOpeningHtml();
18 |     }
19 | 
20 |     public function jsonSerialize()
21 |     {
22 |         return [
23 |             'tag' => $this->tagName,
24 |             'attributes' => $this->attributes,
25 |         ];
26 |     }
27 | 
28 |     public function serialize()
29 |     {
30 |         return serialize($this->jsonSerialize());
31 |     }
32 | 
33 |     public function unserialize($data)
34 |     {
35 |         $data = unserialize($data);
36 | 
37 |         $this->tagName = $data['tag'];
38 |         $this->attributes = $data['attributes'];
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/StringElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace Html;
 5 | 
 6 | final class StringElement implements ElementInterface
 7 | {
 8 |     private $children = [];
 9 | 
10 |     public static function create(string ...$children)
11 |     {
12 |         return new static(...$children);
13 |     }
14 | 
15 |     public function __construct(string ...$children)
16 |     {
17 |         $this->children = $children;
18 |     }
19 | 
20 |     public function __call(string $name, array $arguments): ElementInterface
21 |     {
22 |         return $this;
23 |     }
24 | 
25 |     public function __toString(): string
26 |     {
27 |         return implode('', $this->children);
28 |     }
29 | 
30 |     public function data(string $key, $value): ElementInterface
31 |     {
32 |         return $this;
33 |     }
34 | 
35 |     public function jsonSerialize()
36 |     {
37 |         return [
38 |             'tag' => 'raw',
39 |             'children' => $this->children,
40 |         ];
41 |     }
42 | 
43 |     public function serialize()
44 |     {
45 |         return serialize($this->jsonSerialize());
46 |     }
47 | 
48 |     public function unserialize($data)
49 |     {
50 |         $data = unserialize($data);
51 | 
52 |         $this->children = $data['children'];
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/functions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types = 1);
  3 | 
  4 | namespace Html;
  5 | 
  6 | use InvalidArgumentException;
  7 | 
  8 | function array2Html(array $data): ElementInterface
  9 | {
 10 |     $fn = "Html\\{$data['tag']}";
 11 | 
 12 |     if (!function_exists($fn)) {
 13 |         throw new InvalidArgumentException(
 14 |             sprintf('Function %s does not exists', $fn)
 15 |         );
 16 |     }
 17 | 
 18 |     if ($data['tag'] === 'raw') {
 19 |         $args = [];
 20 |     } else {
 21 |         $args = [$data['attributes'] ?? []];
 22 |     }
 23 | 
 24 |     if (isset($data['children'])) {
 25 |         foreach ($data['children'] as $child) {
 26 |             if (is_array($child)) {
 27 |                 $child = array2Html($child);
 28 |             }
 29 | 
 30 |             $args[] = $child;
 31 |         }
 32 |     }
 33 | 
 34 |     return $fn(...$args);
 35 | }
 36 | function html(...$args): ElementInterface
 37 | {
 38 |     return Element::create('html', $args);
 39 | }
 40 | function base(...$args): ElementInterface
 41 | {
 42 |     return SelfClosingElement::create('base', $args);
 43 | }
 44 | function head(...$args): ElementInterface
 45 | {
 46 |     return Element::create('head', $args);
 47 | }
 48 | function link(...$args): ElementInterface
 49 | {
 50 |     return SelfClosingElement::create('link', $args);
 51 | }
 52 | function meta(...$args): ElementInterface
 53 | {
 54 |     return SelfClosingElement::create('meta', $args);
 55 | }
 56 | function style(...$args): ElementInterface
 57 | {
 58 |     return Element::create('style', $args, Element::NO_ESCAPE_STRINGS);
 59 | }
 60 | function title(...$args): ElementInterface
 61 | {
 62 |     return Element::create('title', $args);
 63 | }
 64 | function body(...$args): ElementInterface
 65 | {
 66 |     return Element::create('body', $args);
 67 | }
 68 | function address(...$args): ElementInterface
 69 | {
 70 |     return Element::create('address', $args);
 71 | }
 72 | function article(...$args): ElementInterface
 73 | {
 74 |     return Element::create('article', $args);
 75 | }
 76 | function aside(...$args): ElementInterface
 77 | {
 78 |     return Element::create('aside', $args);
 79 | }
 80 | function footer(...$args): ElementInterface
 81 | {
 82 |     return Element::create('footer', $args);
 83 | }
 84 | function header(...$args): ElementInterface
 85 | {
 86 |     return Element::create('header', $args);
 87 | }
 88 | function h1(...$args): ElementInterface
 89 | {
 90 |     return Element::create('h1', $args);
 91 | }
 92 | function h2(...$args): ElementInterface
 93 | {
 94 |     return Element::create('h2', $args);
 95 | }
 96 | function h3(...$args): ElementInterface
 97 | {
 98 |     return Element::create('h3', $args);
 99 | }
100 | function h4(...$args): ElementInterface
101 | {
102 |     return Element::create('h4', $args);
103 | }
104 | function h5(...$args): ElementInterface
105 | {
106 |     return Element::create('h5', $args);
107 | }
108 | function h6(...$args): ElementInterface
109 | {
110 |     return Element::create('h6', $args);
111 | }
112 | function main(...$args): ElementInterface
113 | {
114 |     return Element::create('main', $args);
115 | }
116 | function nav(...$args): ElementInterface
117 | {
118 |     return Element::create('nav', $args);
119 | }
120 | function section(...$args): ElementInterface
121 | {
122 |     return Element::create('section', $args);
123 | }
124 | function blockquote(...$args): ElementInterface
125 | {
126 |     return Element::create('blockquote', $args);
127 | }
128 | function dd(...$args): ElementInterface
129 | {
130 |     return Element::create('dd', $args);
131 | }
132 | function div(...$args): ElementInterface
133 | {
134 |     return Element::create('div', $args);
135 | }
136 | function dl(...$args): ElementInterface
137 | {
138 |     return Element::create('dl', $args);
139 | }
140 | function dt(...$args): ElementInterface
141 | {
142 |     return Element::create('dt', $args);
143 | }
144 | function figcaption(...$args): ElementInterface
145 | {
146 |     return Element::create('figcaption', $args);
147 | }
148 | function figure(...$args): ElementInterface
149 | {
150 |     return Element::create('figure', $args);
151 | }
152 | function hr(...$args): ElementInterface
153 | {
154 |     return SelfClosingElement::create('hr', $args);
155 | }
156 | function li(...$args): ElementInterface
157 | {
158 |     return Element::create('li', $args);
159 | }
160 | function ol(...$args): ElementInterface
161 | {
162 |     return Element::create('ol', $args);
163 | }
164 | function p(...$args): ElementInterface
165 | {
166 |     return Element::create('p', $args);
167 | }
168 | function pre(...$args): ElementInterface
169 | {
170 |     return Element::create('pre', $args);
171 | }
172 | function ul(...$args): ElementInterface
173 | {
174 |     return Element::create('ul', $args);
175 | }
176 | function a(...$args): ElementInterface
177 | {
178 |     return Element::create('a', $args);
179 | }
180 | function abbr(...$args): ElementInterface
181 | {
182 |     return Element::create('abbr', $args);
183 | }
184 | function b(...$args): ElementInterface
185 | {
186 |     return Element::create('b', $args);
187 | }
188 | function bdi(...$args): ElementInterface
189 | {
190 |     return Element::create('bdi', $args);
191 | }
192 | function bdo(...$args): ElementInterface
193 | {
194 |     return Element::create('bdo', $args);
195 | }
196 | function br(...$args): ElementInterface
197 | {
198 |     return SelfClosingElement::create('br', $args);
199 | }
200 | function cite(...$args): ElementInterface
201 | {
202 |     return Element::create('cite', $args);
203 | }
204 | function code(...$args): ElementInterface
205 | {
206 |     return Element::create('code', $args);
207 | }
208 | function data(...$args): ElementInterface
209 | {
210 |     return Element::create('data', $args);
211 | }
212 | function dfn(...$args): ElementInterface
213 | {
214 |     return Element::create('dfn', $args);
215 | }
216 | function em(...$args): ElementInterface
217 | {
218 |     return Element::create('em', $args);
219 | }
220 | function i(...$args): ElementInterface
221 | {
222 |     return Element::create('i', $args);
223 | }
224 | function kbd(...$args): ElementInterface
225 | {
226 |     return Element::create('kbd', $args);
227 | }
228 | function mark(...$args): ElementInterface
229 | {
230 |     return Element::create('mark', $args);
231 | }
232 | function q(...$args): ElementInterface
233 | {
234 |     return Element::create('q', $args);
235 | }
236 | function rb(...$args): ElementInterface
237 | {
238 |     return Element::create('rb', $args);
239 | }
240 | function rp(...$args): ElementInterface
241 | {
242 |     return Element::create('rp', $args);
243 | }
244 | function rt(...$args): ElementInterface
245 | {
246 |     return Element::create('rt', $args);
247 | }
248 | function rtc(...$args): ElementInterface
249 | {
250 |     return Element::create('rtc', $args);
251 | }
252 | function ruby(...$args): ElementInterface
253 | {
254 |     return Element::create('ruby', $args);
255 | }
256 | function s(...$args): ElementInterface
257 | {
258 |     return Element::create('s', $args);
259 | }
260 | function samp(...$args): ElementInterface
261 | {
262 |     return Element::create('samp', $args);
263 | }
264 | function small(...$args): ElementInterface
265 | {
266 |     return Element::create('small', $args);
267 | }
268 | function span(...$args): ElementInterface
269 | {
270 |     return Element::create('span', $args);
271 | }
272 | function strong(...$args): ElementInterface
273 | {
274 |     return Element::create('strong', $args);
275 | }
276 | function sub(...$args): ElementInterface
277 | {
278 |     return Element::create('sub', $args);
279 | }
280 | function sup(...$args): ElementInterface
281 | {
282 |     return Element::create('sup', $args);
283 | }
284 | function time(...$args): ElementInterface
285 | {
286 |     return Element::create('time', $args);
287 | }
288 | function u(...$args): ElementInterface
289 | {
290 |     return Element::create('u', $args);
291 | }
292 | function variable(...$args): ElementInterface
293 | {
294 |     return Element::create('var', $args);
295 | }
296 | function wbr(...$args): ElementInterface
297 | {
298 |     return SelfClosingElement::create('wbr', $args);
299 | }
300 | function area(...$args): ElementInterface
301 | {
302 |     return SelfClosingElement::create('area', $args);
303 | }
304 | function audio(...$args): ElementInterface
305 | {
306 |     return Element::create('audio', $args);
307 | }
308 | function img(...$args): ElementInterface
309 | {
310 |     return SelfClosingElement::create('img', $args);
311 | }
312 | function map(...$args): ElementInterface
313 | {
314 |     return Element::create('map', $args);
315 | }
316 | function track(...$args): ElementInterface
317 | {
318 |     return SelfClosingElement::create('track', $args);
319 | }
320 | function video(...$args): ElementInterface
321 | {
322 |     return Element::create('video', $args);
323 | }
324 | function embed(...$args): ElementInterface
325 | {
326 |     return SelfClosingElement::create('embed', $args);
327 | }
328 | function iframe(...$args): ElementInterface
329 | {
330 |     return Element::create('iframe', $args);
331 | }
332 | function object(...$args): ElementInterface
333 | {
334 |     return Element::create('object', $args);
335 | }
336 | function param(...$args): ElementInterface
337 | {
338 |     return SelfClosingElement::create('param', $args);
339 | }
340 | function picture(...$args): ElementInterface
341 | {
342 |     return Element::create('picture', $args);
343 | }
344 | function source(...$args): ElementInterface
345 | {
346 |     return SelfClosingElement::create('source', $args);
347 | }
348 | function canvas(...$args): ElementInterface
349 | {
350 |     return Element::create('canvas', $args);
351 | }
352 | function noscript(...$args): ElementInterface
353 | {
354 |     return Element::create('noscript', $args);
355 | }
356 | function script(...$args): ElementInterface
357 | {
358 |     return Element::create('script', $args, Element::NO_ESCAPE_STRINGS);
359 | }
360 | function del(...$args): ElementInterface
361 | {
362 |     return Element::create('del', $args);
363 | }
364 | function ins(...$args): ElementInterface
365 | {
366 |     return Element::create('ins', $args);
367 | }
368 | function caption(...$args): ElementInterface
369 | {
370 |     return Element::create('caption', $args);
371 | }
372 | function col(...$args): ElementInterface
373 | {
374 |     return SelfClosingElement::create('col', $args);
375 | }
376 | function colgroup(...$args): ElementInterface
377 | {
378 |     return Element::create('colgroup', $args);
379 | }
380 | function table(...$args): ElementInterface
381 | {
382 |     return Element::create('table', $args);
383 | }
384 | function tbody(...$args): ElementInterface
385 | {
386 |     return Element::create('tbody', $args);
387 | }
388 | function td(...$args): ElementInterface
389 | {
390 |     return Element::create('td', $args);
391 | }
392 | function tfoot(...$args): ElementInterface
393 | {
394 |     return Element::create('tfoot', $args);
395 | }
396 | function th(...$args): ElementInterface
397 | {
398 |     return Element::create('th', $args);
399 | }
400 | function thead(...$args): ElementInterface
401 | {
402 |     return Element::create('thead', $args);
403 | }
404 | function tr(...$args): ElementInterface
405 | {
406 |     return Element::create('tr', $args);
407 | }
408 | function button(...$args): ElementInterface
409 | {
410 |     return Element::create('button', $args);
411 | }
412 | function datalist(...$args): ElementInterface
413 | {
414 |     return Element::create('datalist', $args);
415 | }
416 | function fieldset(...$args): ElementInterface
417 | {
418 |     return Element::create('fieldset', $args);
419 | }
420 | function form(...$args): ElementInterface
421 | {
422 |     return Element::create('form', $args);
423 | }
424 | function input(...$args): ElementInterface
425 | {
426 |     return SelfClosingElement::create('input', $args);
427 | }
428 | function label(...$args): ElementInterface
429 | {
430 |     return Element::create('label', $args);
431 | }
432 | function legend(...$args): ElementInterface
433 | {
434 |     return Element::create('legend', $args);
435 | }
436 | function meter(...$args): ElementInterface
437 | {
438 |     return Element::create('meter', $args);
439 | }
440 | function optgroup(...$args): ElementInterface
441 | {
442 |     return Element::create('optgroup', $args);
443 | }
444 | function option(...$args): ElementInterface
445 | {
446 |     return Element::create('option', $args);
447 | }
448 | function output(...$args): ElementInterface
449 | {
450 |     return Element::create('output', $args);
451 | }
452 | function progress(...$args): ElementInterface
453 | {
454 |     return Element::create('progress', $args);
455 | }
456 | function select(...$args): ElementInterface
457 | {
458 |     return Element::create('select', $args);
459 | }
460 | function textarea(...$args): ElementInterface
461 | {
462 |     return Element::create('textarea', $args);
463 | }
464 | function details(...$args): ElementInterface
465 | {
466 |     return Element::create('details', $args);
467 | }
468 | function dialog(...$args): ElementInterface
469 | {
470 |     return Element::create('dialog', $args);
471 | }
472 | function summary(...$args): ElementInterface
473 | {
474 |     return Element::create('summary', $args);
475 | }
476 | function slot(...$args): ElementInterface
477 | {
478 |     return Element::create('slot', $args);
479 | }
480 | function template(...$args): ElementInterface
481 | {
482 |     return Element::create('template', $args);
483 | }
484 | function raw(string ...$strings): ElementInterface
485 | {
486 |     return StringElement::create(...$strings);
487 | }
488 | 


--------------------------------------------------------------------------------