@awesomeness-js/server 1.1.11 → 1.1.14

package/tests/componentDependencies.test.js

@@ -0,0 +1,85 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { pathToFileURL } from "url";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { clearComponentAndPageMemory } from "../src/componentAndPageMemory.js";
+
+const mocks = vi.hoisted(() => ({
+	getConfig: vi.fn(),
+}));
+
+vi.mock("../src/getConfig.js", () => ({
+	default: mocks.getConfig,
+}));
+
+import componentDependencies from "../src/componentDependencies.js";
+
+describe("componentDependencies", () => {
+
+	let tempRoot;
+
+	function writeComponentFile(componentName, relativeFilePath, content) {
+
+		const filePath = path.join(tempRoot, componentName, relativeFilePath);
+
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.writeFileSync(filePath, content);
+
+	}
+
+	beforeEach(() => {
+
+		clearComponentAndPageMemory();
+		tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "awes-component-deps-"));
+		mocks.getConfig.mockReturnValue({});
+
+	});
+
+	afterEach(() => {
+
+		clearComponentAndPageMemory();
+		fs.rmSync(tempRoot, {
+			recursive: true,
+			force: true 
+		});
+		vi.clearAllMocks();
+
+	});
+
+	it("recursively resolves transitive dependencies through nested component files", () => {
+
+		writeComponentFile("alpha", "index.js", `export default function alpha() {
+	ui.beta.start();
+	return true;
+}`);
+
+		writeComponentFile("beta", path.join("nested", "index.js"), `export default function betaNested() {
+	ui.gamma.mount();
+	return true;
+}`);
+
+		writeComponentFile("gamma", path.join("deeper", "bridge.js"), `export default function gammaBridge() {
+	ui.delta.render();
+	return true;
+}`);
+
+		writeComponentFile("delta", "index.js", `export default function delta() {
+	return "done";
+}`);
+
+		const out = componentDependencies([ "alpha" ], {
+			componentLocations: [ pathToFileURL(tempRoot + path.sep) ],
+			namespace: "ui",
+		});
+
+		expect(Object.keys(out).sort()).toEqual([ "alpha", "beta", "delta", "gamma" ]);
+		expect(out.alpha.js).toContain("ui.alpha = function alpha()");
+		expect(out.beta.js).toContain("ui.beta.nested = function betaNested()");
+		expect(out.gamma.js).toContain("ui.gamma.deeper.bridge = function gammaBridge()");
+		expect(out.delta.js).toContain("ui.delta = function delta()");
+
+	});
+
+});

package/tests/fetchPage.test.js

@@ -48,6 +48,7 @@ describe("fetchPage component inference", () => {
 		"css"
 	);
 	const expectedComponents = [
+		"app",
 		"card",
 		"cardMain",
 		"cardMount",
@@ -201,6 +202,7 @@ describe("fetchPage component inference", () => {
 		console.log("fetchPage inferred components (no about.components)", inferred);
 
 		expect(inferred).toEqual([
+			"app",
 			"cardMain",
 			"cardMount",
 			"pageInit",

package/tests/fixtures/site-and-components/components/app/cleanMain/index.js

@@ -0,0 +1,26 @@
+export default ({
+	withFullScreenHero = false
+} = {}) => {
+
+	if(!app.$main){
+
+		app.$main = $('#main');
+	
+	}
+
+	if(withFullScreenHero){
+
+		app.$main.addClass('withFullScreenHero');
+	
+	} else {
+
+		app.$main.removeClass('withFullScreenHero');
+	
+	}
+
+	app.$main.empty();
+	$(document).scrollTop(0);
+
+	return app.$main;
+
+};

package/tests/fixtures/site-and-components/components/app/cleanMain.js

@@ -0,0 +1,14 @@
+export default () => {
+
+	if(!app.$main){
+
+		app.$main = $('#main');
+	
+	}
+
+	app.$main.empty();
+	$(document).scrollTop(0);
+
+	return app.$main;
+
+};

package/tests/fixtures/site-and-components/components/app/index.css

@@ -0,0 +1,4 @@
+#app {
+    margin: 0;
+    padding: 0;
+}

package/tests/fixtures/site-and-components/components/app/index.js

@@ -0,0 +1,42 @@
+import ui from '#ui';
+
+export default function silentStart({
+	theme = {
+		name: 'light',
+		neutralColor: 'zinc',
+		accentColor: 'cyan',
+		customColors: {},
+	}
+}) {
+
+	app.theme = theme;
+
+	if(theme.customColors){
+
+		$.each(theme.customColors, (name, hexValue) => {
+
+			let inputColor;
+			let anchorShade = 600;
+
+			if(typeof hexValue === 'string'){
+
+				inputColor = hexValue;
+
+			} else if(typeof hexValue === 'object' && hexValue !== null){
+
+				inputColor = hexValue.inputColor;
+				anchorShade = hexValue.anchorShade || anchorShade;
+
+			}
+
+			ui.colors.custom({
+				inputColor: inputColor,
+				anchorShade: 600,
+				name
+			});
+
+		});
+
+	}
+
+}

package/tests/fixtures/site-and-components/components/app/insertIntoList.jquery.js

@@ -0,0 +1,150 @@
+(function(){
+
+	// IMPORTANT NOTE: with custom sortFn's use toLowerCase !!
+	$.fn.extend({
+
+		//Name the function
+		insertIntoList: function($ul, options) {
+
+			var defaults = {
+				'sortFn':function($elm){
+
+					return $elm.html().toLowerCase(); 
+
+				},
+				'insertBeforeLast':false,
+				'za':false,
+				'selector':null
+			};
+
+			var options =  $.extend(defaults, options); // jshint ignore:line
+
+			return this.each(function() {
+
+				if(!$ul){
+
+					return false; 
+
+				}
+
+				// From here on in, it's "normal" jQuery
+
+				var $li = $(this); // new item
+				var $lis;
+
+
+				if(options.selector){
+
+					$lis = $ul.children(options.selector); // existing items
+				
+				} else {
+
+					$lis = $ul.children(); // existing items
+				
+				}
+
+				var newHtml = options.sortFn($li);
+
+				if($lis.length === 0){
+
+					$li.appendTo($ul); 
+
+					return; 
+
+				}
+
+				$lis.each(function(k,e){
+
+					var $t = $(this);
+
+					// meta hack for skip
+					if($t.data('insertIntoListSkip') === true){
+
+						return true; 
+
+					}
+
+					var isLast = $t.is( ":last-child" );
+					var current = options.sortFn($t);
+
+					if(options.insertBeforeLast && isLast){
+
+						// insert before last child
+						$li.insertBefore($t);
+						
+						return false;
+
+					}
+
+					if(options.za){
+
+						if(current < newHtml){
+
+							$li.insertBefore($t);
+							
+							return false;
+
+						} else {
+
+							// continue if it is not the last item
+							if(!isLast){
+
+								return true; 
+
+							}
+
+							// it is the last item
+							if(options.insertBeforeLast){
+
+								$li.insertBefore($t);
+							
+							} else {
+
+								$li.insertAfter($t);
+							
+							}
+
+						}
+
+					} else {
+
+						if(current > newHtml){
+
+							$li.insertBefore($t);
+							
+							return false;
+
+						} else {
+
+							// continue if it is not the last item
+							if(!isLast){
+
+								return true; 
+
+							}
+
+							// it is the last item
+							if(options.insertBeforeLast){
+
+								$li.insertBefore($t);
+							
+							} else {
+
+								$li.insertAfter($t);
+							
+							}
+
+						}
+
+					}
+
+
+				});
+
+  			}); // each CORE
+
+		} // xoSelect Function
+
+	}); // extend
+
+})();

package/tests/fixtures/site-and-components/components/app/keyUpWithTimeout.jQuery.js

@@ -0,0 +1,26 @@
+(function() {
+	
+	$.fn.keyUpWithTimeout = function(callback, timeout) {
+	  
+		var timer;
+	  
+	  return this.each(function() {
+
+			let $this = $(this);
+
+			$this.on('keyup', function() {
+			
+				clearTimeout(timer);
+				timer = setTimeout(function() {
+
+					callback($this.val(), this);
+				
+				}, timeout);
+			
+			});
+	  
+		});
+	
+	};
+	
+})();

package/tests/fixtures/site-and-components/components/app/onEnter.jQuery.js

@@ -0,0 +1,39 @@
+(function(){
+
+	$.fn.extend({
+		//Name the function
+		onEnter: function(fn) {
+
+			if(typeof(fn) != 'function'){
+
+				console.log('function not passed to onEnter.');
+				
+				return false;
+			
+			}
+
+			return this.each(function() {
+
+				// From here on in, it's "normal" jQuery
+				var $t = $(this);
+
+				$t.off('keypress').on('keypress', function(e){
+
+					var keycode = (e.keyCode ? e.keyCode : e.which);
+
+
+					if (keycode == '13') {
+
+						e.preventDefault();
+						fn.call();
+					
+					}
+				
+				});
+			
+			});
+		
+		}
+	});
+
+})();

package/tests/fixtures/site-and-components/components/app/onResize.jQuery.js

@@ -0,0 +1,64 @@
+(function() {
+
+	$.fn.onResize = function(callback, { 
+		widthChangeOnly = true
+	} = {}) {
+
+		this.each(function() {
+
+			if (typeof callback !== 'function') {
+
+				return this; 
+
+			}
+
+			let lastKnownSize = 0;
+
+			function resize(entries) {
+
+
+				if (!$.contains(document, $element[0])) {
+
+					resizeObserver.disconnect();
+					
+					return;
+
+				}
+
+				let currentSize = $element.width();
+
+
+				if(widthChangeOnly){
+
+					if (currentSize !== lastKnownSize) {
+
+						lastKnownSize = currentSize;
+
+						callback.call($element, currentSize);
+
+					}
+			
+				} else {
+
+					callback.call($element, currentSize);
+
+				}
+			
+			}
+
+			var $element = $(this);
+			var resizeObserver = new ResizeObserver(resize);
+
+			// Start observing the element
+			resizeObserver.observe($element[0]);
+
+			$element.on('resize', resize );
+
+		});
+
+		// Return this for jQuery chaining
+		return this;
+
+	};
+
+})();