feat: VivesPOS landing on Winter CMS 1.2 — theme + plugin + Dockerfile

- Base: wintercms/winter branch 1.2 (full framework)
- Theme vivespos: Canvas 7 + Bootstrap 5 CDN, custom CSS
- Layout: deferred GTM/GA4 tracking, JSON-LD SoftwareApplication
- Partials: hero (offline-first), features, modes (offline/nube toggle),
  screenshots, pricing (3 planes), comparison, FAQ, CTA
- Plugin VivesPOS.Site with ContactForm
- Dockerfile: PHP 8.2 Apache, port 80, healthcheck
- Added winter/wn-pages, blog, sitemap, seo plugins
- Active theme set to vivespos

modules/system/tests/js/fixtures/dataConfig/DataConfigFixture.js

@@ -0,0 +1,26 @@
+/* globals window */
+
+((Snowboard) => {
+    class DataConfigFixture extends Snowboard.PluginBase {
+        construct(element) {
+            this.element = element;
+            this.config = this.snowboard.dataConfig(this, element);
+        }
+
+        dependencies() {
+            return ['dataConfig'];
+        }
+
+        defaults() {
+            return {
+                id: null,
+                name: null,
+                stringValue: null,
+                boolean: null,
+                base64: null,
+            };
+        }
+    }
+
+    Snowboard.addPlugin('dataConfigFixture', DataConfigFixture);
+})(window.Snowboard);

modules/system/tests/js/fixtures/formWidget/FormWidgetStubs.js

@@ -0,0 +1,39 @@
+/*
+ * Stubs for testing winter.form.js in isolation.
+ *
+ * Provides minimal implementations of WinterCMS dependencies that the
+ * form widget relies on at load time.
+ */
+
+// ocJSON - used by paramToObj inside the form widget
+window.ocJSON = function (str) {
+    return JSON.parse(str);
+};
+
+// $(document).render() - used by the form widget to auto-initialize on DOM ready
+jQuery.fn.render = function (fn) {
+    fn();
+};
+
+/*
+ * $.fn.request() - stub that mimics WinterCMS's AJAX framework contract.
+ *
+ * Returns a resolved jQuery Deferred with .done()/.fail()/.always() and a
+ * .success() alias (matching the WinterCMS framework.js Request class).
+ * The deferred resolves immediately since there is no real network I/O.
+ */
+jQuery.fn.request = function (handler, options) {
+    var deferred = jQuery.Deferred();
+
+    deferred.success = function (fn) {
+        return deferred.done(fn);
+    };
+
+    deferred.resolve();
+    return deferred;
+};
+
+// $.fn.loadIndicator() - no-op stub
+jQuery.fn.loadIndicator = function () {
+    return this;
+};

modules/system/tests/js/fixtures/framework/TestClosureListener.js

@@ -0,0 +1,18 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestClosureListener extends Snowboard.Singleton {
+        listens() {
+            return {
+                eventOne: () => {
+                    this.eventResult = 'Closure eventOne called';
+                },
+                eventTwo: (arg) => {
+                    this.eventResult = `Closure eventTwo called with arg '${arg}'`;
+                }
+            };
+        }
+    }
+
+    Snowboard.addPlugin('testClosure', TestClosureListener);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestDependencyOne.js

@@ -0,0 +1,11 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestDependencyOne extends Snowboard.Singleton {
+        testMethod() {
+            return 'Tested';
+        }
+    }
+
+    Snowboard.addPlugin('testDependencyOne', TestDependencyOne);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestDependencyTwo.js

@@ -0,0 +1,11 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestDependencyTwo extends Snowboard.Singleton {
+        testMethod() {
+            return 'Tested';
+        }
+    }
+
+    Snowboard.addPlugin('testDependencyTwo', TestDependencyTwo);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestHasDependencies.js

@@ -0,0 +1,15 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestHasDependencies extends Snowboard.Singleton {
+        dependencies() {
+            return ['testDependencyOne', 'testDependencyTwo'];
+        }
+
+        testMethod() {
+            return 'Tested';
+        }
+    }
+
+    Snowboard.addPlugin('testHasDependencies', TestHasDependencies);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestListener.js

@@ -0,0 +1,18 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestListener extends Snowboard.Singleton {
+        listens() {
+            return {
+                eventOne: 'eventOne',
+                eventTwo: 'notExists'
+            };
+        }
+
+        eventOne(arg) {
+            this.eventResult = 'Event called with arg ' + arg;
+        }
+    }
+
+    Snowboard.addPlugin('test', TestListener);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestPlugin.js

@@ -0,0 +1,11 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestPlugin extends Snowboard.PluginBase {
+        testMethod() {
+            return 'Tested';
+        }
+    }
+
+    Snowboard.addPlugin('testPlugin', TestPlugin);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestPromiseClosureListener.js

@@ -0,0 +1,24 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestPromiseClosureListener extends Snowboard.Singleton {
+        listens() {
+            return {
+                promiseOne: (arg) => {
+                    return new Promise((resolve) => {
+                        window.setTimeout(() => {
+                            this.eventResult = 'Event called with arg ' + arg;
+                            resolve();
+                        }, 500);
+                    });
+                },
+                promiseTwo: (arg) => {
+                    this.eventResult = 'Promise two called with arg ' + arg;
+                    return true;
+                },
+            };
+        }
+    }
+
+    Snowboard.addPlugin('testClosure', TestPromiseClosureListener);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestPromiseListener.js

@@ -0,0 +1,28 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestPromiseListener extends Snowboard.Singleton {
+        listens() {
+            return {
+                promiseOne: 'promiseOne',
+                promiseTwo: 'promiseTwo'
+            };
+        }
+
+        promiseOne(arg) {
+            return new Promise((resolve) => {
+                window.setTimeout(() => {
+                    this.eventResult = 'Event called with arg ' + arg;
+                    resolve();
+                }, 500);
+            });
+        }
+
+        promiseTwo(arg) {
+            this.eventResult = 'Promise two called with arg ' + arg;
+            return true;
+        }
+    }
+
+    Snowboard.addPlugin('test', TestPromiseListener);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestSingleton.js

@@ -0,0 +1,11 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestSingleton extends Snowboard.Singleton {
+        testMethod() {
+            return 'Tested';
+        }
+    }
+
+    Snowboard.addPlugin('testSingleton', TestSingleton);
+})(window.Snowboard);

modules/system/tests/js/fixtures/framework/TestSingletonWithDependency.js

@@ -0,0 +1,29 @@
+/* globals window */
+
+((Snowboard) => {
+    class TestSingletonWithDependency extends Snowboard.Singleton {
+        dependencies() {
+            return ['testDependencyOne'];
+        }
+
+        listens() {
+            return {
+                ready: 'ready',
+            };
+        }
+
+        ready() {
+            return 'Ready';
+        }
+
+        testMethod() {
+            return 'Tested';
+        }
+
+        dependencyTest() {
+            return this.snowboard.testDependencyOne().testMethod();
+        }
+    }
+
+    Snowboard.addPlugin('testSingleton', TestSingletonWithDependency);
+})(window.Snowboard);