Build modified streamline images

The official image from streamline does not currently work for the arm64
platform. As a temporary measure, the source code and docker build scripts
have been lifted from the official images and are used to build locally.

Some additional modifications are made to reduce overall image size, these
are documented in docker/README.md

docker/streamline-src/vendor/dflydev/dot-access-data/src/Data.php

@@ -0,0 +1,286 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is a part of dflydev/dot-access-data.
+ *
+ * (c) Dragonfly Development Inc.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Dflydev\DotAccessData;
+
+use ArrayAccess;
+use Dflydev\DotAccessData\Exception\DataException;
+use Dflydev\DotAccessData\Exception\InvalidPathException;
+use Dflydev\DotAccessData\Exception\MissingPathException;
+
+/**
+ * @implements ArrayAccess<string, mixed>
+ */
+class Data implements DataInterface, ArrayAccess
+{
+    private const DELIMITERS = ['.', '/'];
+
+    /**
+     * Internal representation of data data
+     *
+     * @var array<string, mixed>
+     */
+    protected $data;
+
+    /**
+     * Constructor
+     *
+     * @param array<string, mixed> $data
+     */
+    public function __construct(array $data = [])
+    {
+        $this->data = $data;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function append(string $key, $value = null): void
+    {
+        $currentValue =& $this->data;
+        $keyPath = self::keyToPathArray($key);
+
+        $endKey = array_pop($keyPath);
+        foreach ($keyPath as $currentKey) {
+            if (! isset($currentValue[$currentKey])) {
+                $currentValue[$currentKey] = [];
+            }
+            $currentValue =& $currentValue[$currentKey];
+        }
+
+        if (!isset($currentValue[$endKey])) {
+            $currentValue[$endKey] = [];
+        }
+
+        if (!is_array($currentValue[$endKey])) {
+            // Promote this key to an array.
+            // TODO: Is this really what we want to do?
+            $currentValue[$endKey] = [$currentValue[$endKey]];
+        }
+
+        $currentValue[$endKey][] = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set(string $key, $value = null): void
+    {
+        $currentValue =& $this->data;
+        $keyPath = self::keyToPathArray($key);
+
+        $endKey = array_pop($keyPath);
+        foreach ($keyPath as $currentKey) {
+            if (!isset($currentValue[$currentKey])) {
+                $currentValue[$currentKey] = [];
+            }
+            if (!is_array($currentValue[$currentKey])) {
+                throw new DataException(sprintf('Key path "%s" within "%s" cannot be indexed into (is not an array)', $currentKey, self::formatPath($key)));
+            }
+            $currentValue =& $currentValue[$currentKey];
+        }
+        $currentValue[$endKey] = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function remove(string $key): void
+    {
+        $currentValue =& $this->data;
+        $keyPath = self::keyToPathArray($key);
+
+        $endKey = array_pop($keyPath);
+        foreach ($keyPath as $currentKey) {
+            if (!isset($currentValue[$currentKey])) {
+                return;
+            }
+            $currentValue =& $currentValue[$currentKey];
+        }
+        unset($currentValue[$endKey]);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @psalm-mutation-free
+     */
+    public function get(string $key, $default = null)
+    {
+        /** @psalm-suppress ImpureFunctionCall */
+        $hasDefault = \func_num_args() > 1;
+
+        $currentValue = $this->data;
+        $keyPath = self::keyToPathArray($key);
+
+        foreach ($keyPath as $currentKey) {
+            if (!is_array($currentValue) || !array_key_exists($currentKey, $currentValue)) {
+                if ($hasDefault) {
+                    return $default;
+                }
+
+                throw new MissingPathException($key, sprintf('No data exists at the given path: "%s"', self::formatPath($keyPath)));
+            }
+
+            $currentValue = $currentValue[$currentKey];
+        }
+
+        return $currentValue === null ? $default : $currentValue;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @psalm-mutation-free
+     */
+    public function has(string $key): bool
+    {
+        $currentValue = $this->data;
+
+        foreach (self::keyToPathArray($key) as $currentKey) {
+            if (
+                !is_array($currentValue) ||
+                !array_key_exists($currentKey, $currentValue)
+            ) {
+                return false;
+            }
+            $currentValue = $currentValue[$currentKey];
+        }
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @psalm-mutation-free
+     */
+    public function getData(string $key): DataInterface
+    {
+        $value = $this->get($key);
+        if (is_array($value) && Util::isAssoc($value)) {
+            return new Data($value);
+        }
+
+        throw new DataException(sprintf('Value at "%s" could not be represented as a DataInterface', self::formatPath($key)));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function import(array $data, int $mode = self::REPLACE): void
+    {
+        $this->data = Util::mergeAssocArray($this->data, $data, $mode);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function importData(DataInterface $data, int $mode = self::REPLACE): void
+    {
+        $this->import($data->export(), $mode);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @psalm-mutation-free
+     */
+    public function export(): array
+    {
+        return $this->data;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetExists($key)
+    {
+        return $this->has($key);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return mixed
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetGet($key)
+    {
+        return $this->get($key, null);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param string $key
+     * @param mixed $value
+     *
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetSet($key, $value)
+    {
+        $this->set($key, $value);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetUnset($key)
+    {
+        $this->remove($key);
+    }
+
+    /**
+     * @param string $path
+     *
+     * @return string[]
+     *
+     * @psalm-return non-empty-list<string>
+     *
+     * @psalm-pure
+     */
+    protected static function keyToPathArray(string $path): array
+    {
+        if (\strlen($path) === 0) {
+            throw new InvalidPathException('Path cannot be an empty string');
+        }
+
+        $path = \str_replace(self::DELIMITERS, '.', $path);
+
+        return \explode('.', $path);
+    }
+
+    /**
+     * @param string|string[] $path
+     *
+     * @return string
+     *
+     * @psalm-pure
+     */
+    protected static function formatPath($path): string
+    {
+        if (is_string($path)) {
+            $path = self::keyToPathArray($path);
+        }
+
+        return implode(' » ', $path);
+    }
+}

docker/streamline-src/vendor/dflydev/dot-access-data/src/DataInterface.php

@@ -0,0 +1,131 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is a part of dflydev/dot-access-data.
+ *
+ * (c) Dragonfly Development Inc.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Dflydev\DotAccessData;
+
+use Dflydev\DotAccessData\Exception\DataException;
+use Dflydev\DotAccessData\Exception\InvalidPathException;
+
+interface DataInterface
+{
+    public const PRESERVE = 0;
+    public const REPLACE = 1;
+    public const MERGE = 2;
+
+    /**
+     * Append a value to a key (assumes key refers to an array value)
+     *
+     * If the key does not yet exist it will be created.
+     * If the key references a non-array it's existing contents will be added into a new array before appending the new value.
+     *
+     * @param string $key
+     * @param mixed  $value
+     *
+     * @throws InvalidPathException if the given key is empty
+     */
+    public function append(string $key, $value = null): void;
+
+    /**
+     * Set a value for a key
+     *
+     * If the key does not yet exist it will be created.
+     *
+     * @param string $key
+     * @param mixed  $value
+     *
+     * @throws InvalidPathException if the given key is empty
+     * @throws DataException if the given key does not target an array
+     */
+    public function set(string $key, $value = null): void;
+
+    /**
+     * Remove a key
+     *
+     * No exception will be thrown if the key does not exist
+     *
+     * @param string $key
+     *
+     * @throws InvalidPathException if the given key is empty
+     */
+    public function remove(string $key): void;
+
+    /**
+     * Get the raw value for a key
+     *
+     * If the key does not exist, an optional default value can be returned instead.
+     * If no default is provided then an exception will be thrown instead.
+     *
+     * @param string $key
+     * @param mixed $default
+     *
+     * @return mixed
+     *
+     * @throws InvalidPathException if the given key is empty
+     * @throws InvalidPathException if the given key does not exist and no default value was given
+     *
+     * @psalm-mutation-free
+     */
+    public function get(string $key, $default = null);
+
+    /**
+     * Check if the key exists
+     *
+     * @param string $key
+     *
+     * @return bool
+     *
+     * @throws InvalidPathException if the given key is empty
+     *
+     * @psalm-mutation-free
+     */
+    public function has(string $key): bool;
+
+    /**
+     * Get a data instance for a key
+     *
+     * @param string $key
+     *
+     * @return DataInterface
+     *
+     * @throws InvalidPathException if the given key is empty
+     * @throws DataException if the given key does not reference an array
+     *
+     * @psalm-mutation-free
+     */
+    public function getData(string $key): DataInterface;
+
+    /**
+     * Import data into existing data
+     *
+     * @param array<string, mixed>                     $data
+     * @param self::PRESERVE|self::REPLACE|self::MERGE $mode
+     */
+    public function import(array $data, int $mode = self::REPLACE): void;
+
+    /**
+     * Import data from an external data into existing data
+     *
+     * @param DataInterface                            $data
+     * @param self::PRESERVE|self::REPLACE|self::MERGE $mode
+     */
+    public function importData(DataInterface $data, int $mode = self::REPLACE): void;
+
+    /**
+     * Export data as raw data
+     *
+     * @return array<string, mixed>
+     *
+     * @psalm-mutation-free
+     */
+    public function export(): array;
+}

docker/streamline-src/vendor/dflydev/dot-access-data/src/Exception/DataException.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is a part of dflydev/dot-access-data.
+ *
+ * (c) Dragonfly Development Inc.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Dflydev\DotAccessData\Exception;
+
+/**
+ * Base runtime exception type thrown by this library
+ */
+class DataException extends \RuntimeException
+{
+}

docker/streamline-src/vendor/dflydev/dot-access-data/src/Exception/InvalidPathException.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is a part of dflydev/dot-access-data.
+ *
+ * (c) Dragonfly Development Inc.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Dflydev\DotAccessData\Exception;
+
+/**
+ * Thrown when trying to access an invalid path in the data array
+ */
+class InvalidPathException extends DataException
+{
+}

docker/streamline-src/vendor/dflydev/dot-access-data/src/Exception/MissingPathException.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is a part of dflydev/dot-access-data.
+ *
+ * (c) Dragonfly Development Inc.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Dflydev\DotAccessData\Exception;
+
+use Throwable;
+
+/**
+ * Thrown when trying to access a path that does not exist
+ */
+class MissingPathException extends DataException
+{
+    /** @var string */
+    protected $path;
+
+    public function __construct(string $path, string $message = '', int $code = 0, Throwable $previous = null)
+    {
+        $this->path = $path;
+
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function getPath(): string
+    {
+        return $this->path;
+    }
+}

docker/streamline-src/vendor/dflydev/dot-access-data/src/Util.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is a part of dflydev/dot-access-data.
+ *
+ * (c) Dragonfly Development Inc.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Dflydev\DotAccessData;
+
+class Util
+{
+    /**
+     * Test if array is an associative array
+     *
+     * Note that this function will return true if an array is empty. Meaning
+     * empty arrays will be treated as if they are associative arrays.
+     *
+     * @param array<mixed> $arr
+     *
+     * @return bool
+     *
+     * @psalm-pure
+     */
+    public static function isAssoc(array $arr): bool
+    {
+        return !count($arr) || count(array_filter(array_keys($arr), 'is_string')) == count($arr);
+    }
+
+    /**
+     * Merge contents from one associtative array to another
+     *
+     * @param mixed $to
+     * @param mixed $from
+     * @param DataInterface::PRESERVE|DataInterface::REPLACE|DataInterface::MERGE $mode
+     *
+     * @return mixed
+     *
+     * @psalm-pure
+     */
+    public static function mergeAssocArray($to, $from, int $mode = DataInterface::REPLACE)
+    {
+        if ($mode === DataInterface::MERGE && self::isList($to) && self::isList($from)) {
+            return array_merge($to, $from);
+        }
+
+        if (is_array($from) && is_array($to)) {
+            foreach ($from as $k => $v) {
+                if (!isset($to[$k])) {
+                    $to[$k] = $v;
+                } else {
+                    $to[$k] = self::mergeAssocArray($to[$k], $v, $mode);
+                }
+            }
+
+            return $to;
+        }
+
+        return $mode === DataInterface::PRESERVE ? $to : $from;
+    }
+
+    /**
+     * @param mixed $value
+     *
+     * @return bool
+     *
+     * @psalm-pure
+     */
+    private static function isList($value): bool
+    {
+        return is_array($value) && array_values($value) === $value;
+    }
+}