@awesomeness-js/server 1.1.11 → 1.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@awesomeness-js/server",
-	"version": "1.1.11",
+	"version": "1.1.13",
 	"description": "Awesomeness Multi-Site Server",
 	"author": "Scott Forte",
 	"type": "module",

package/src/componentAndPageMemory.js

@@ -8,6 +8,13 @@ const REFS_CACHE_LIMIT = 5000;
 const fileCache = new Map();
 const refsCache = new Map();
 
+const DEFAULT_EXTRACT_OPTIONS = Object.freeze({
+	namespace: "ui",
+	includeCall: true,
+	includeDotAccess: false,
+	cacheContext: "",
+});
+
 function toMB(bytes) {
 
 	return Number((bytes / (1024 * 1024)).toFixed(6));
@@ -62,14 +69,35 @@ function hashContent(content) {
 
 }
 
-function refsCacheKey(content, options) {
+function normalizeExtractOptions(
+	{
+		namespace = DEFAULT_EXTRACT_OPTIONS.namespace,
+		includeCall = DEFAULT_EXTRACT_OPTIONS.includeCall,
+		includeDotAccess = DEFAULT_EXTRACT_OPTIONS.includeDotAccess,
+		cacheContext,
+	} = {},
+	{
+		defaultCacheContext = DEFAULT_EXTRACT_OPTIONS.cacheContext,
+	} = {}
+) {
+
+	return {
+		namespace,
+		includeCall,
+		includeDotAccess,
+		cacheContext: cacheContext ?? defaultCacheContext,
+	};
+
+}
+
+function refsCacheKey(content, options = {}) {
 
 	const {
-		namespace = "ui",
-		includeCall = true,
-		includeDotAccess = false,
-		cacheContext = "",
-	} = options || {};
+		namespace,
+		includeCall,
+		includeDotAccess,
+		cacheContext,
+	} = normalizeExtractOptions(options);
 	const contentHash = hashContent(content);
 	const contextPart = cacheContext ? `${cacheContext}|` : "";
 
@@ -80,11 +108,13 @@ function refsCacheKey(content, options) {
 function refsCacheKeyFromFile(filePath, fileMeta, options = {}) {
 
 	const {
-		namespace = "ui",
-		includeCall = true,
-		includeDotAccess = false,
-		cacheContext = `file:${filePath}`,
-	} = options || {};
+		namespace,
+		includeCall,
+		includeDotAccess,
+		cacheContext,
+	} = normalizeExtractOptions(options, {
+		defaultCacheContext: `file:${filePath}`,
+	});
 	const contextPart = cacheContext ? `${cacheContext}|` : "";
 
 	return `${contextPart}${namespace}|${includeCall}|${includeDotAccess}|mtime:${fileMeta.mtimeMs}|size:${fileMeta.size}`;
@@ -134,7 +164,8 @@ export function extractUiRefsMemoized(content, options = {}) {
 	
 	}
 
-	const key = refsCacheKey(content, options);
+	const extractionOptions = normalizeExtractOptions(options);
+	const key = refsCacheKey(content, extractionOptions);
 	const existing = refsCache.get(key);
 
 	if (existing) {
@@ -143,7 +174,7 @@ export function extractUiRefsMemoized(content, options = {}) {
 	
 	}
 
-	const refs = extractUiComponentRefs(content, options);
+	const refs = extractUiComponentRefs(content, extractionOptions);
 
 	refsCache.set(key, refs);
 	pruneCache(refsCache, REFS_CACHE_LIMIT);
@@ -155,12 +186,9 @@ export function extractUiRefsMemoized(content, options = {}) {
 export function extractUiRefsFromFileMemoized(filePath, options = {}) {
 
 	const fileEntry = getFileCacheEntry(filePath);
-	const extractionOptions = options.cacheContext
-		? options
-		: {
-			...options,
-			cacheContext: `file:${filePath}`,
-		};
+	const extractionOptions = normalizeExtractOptions(options, {
+		defaultCacheContext: `file:${filePath}`,
+	});
 	const key = refsCacheKeyFromFile(filePath, fileEntry, extractionOptions);
 	const existing = refsCache.get(key);
 

package/src/componentDependencies.js

@@ -2,10 +2,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 import { each, getAllFiles } from "@awesomeness-js/utils";
 import getConfig from "./getConfig.js";
-import {
-	extractUiRefsFromFileMemoized,
-	readFileMemoized,
-} from "./componentAndPageMemory.js";
+import { extractUiRefsFromFileMemoized, readFileMemoized } from "./componentAndPageMemory.js";
 
 function urlToFsPath(u) {
 
@@ -182,6 +179,7 @@ export default function componentDependencies(
 
 						const newTest = extractUiRefsFromFileMemoized(filePath, {
 							namespace,
+							includeDotAccess: true,
 							cacheContext: `component:${component}|file:${filePath}`,
 						});
 

package/tests/componentAndPageMemory.test.js

@@ -79,6 +79,7 @@ describe("componentAndPageMemory", () => {
 
 		console.log("components gathered", gatheredComponents);
 		expect(gatheredComponents).toEqual([
+			"app",
 			"card",
 			"cardMain",
 			"cardMount",

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;
+
+	};
+
+})();