agnostics 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# Agnostics
+
+![agnostics](./diogenes.jpg)

package/lib/helpers/_Express.js

@@ -0,0 +1,30 @@
+
+// eventually API structure
+
+/*
+
+	easy peasy
+
+	/helloworld 
+	/foo
+	/foo/:id/bar
+	/foo/:id/bar/:name
+	/foo/list
+	/foo/list/:offset
+	/foo/list/:offset/really/:deep/thing/:right/here
+	/foo/list/:offset/really/:deep/thing/:right/here/:ooooh
+
+	.scriptName('api')
+	.command('helloworld')
+	.command('foo <id> bar [name]')
+	.command('foo')
+	.command('foo list [offset]')
+	.command('foo list <offset> really <deep> thing <right> here [ooooh]')
+
+
+	RULES: last one is always optional (to avoid conflicts)
+
+
+
+
+*/

package/lib/helpers/_Parsers.js

@@ -0,0 +1,73 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//                PARSING               //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+// --------- MIME BUCKETS ---------
+
+const BUCKETS = {
+	image: ['jpg', 'jpeg', 'png', 'gif', 'svg', 'webp', 'bmp', 'ico'],
+	video: ['mp4', 'webm', 'ogg', 'mov', 'avi', 'mkv'],
+	audio: ['mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a'],
+	text:  ['txt', 'md', 'csv', 'html', 'css', 'js', 'json'],
+	font:  ['woff', 'woff2', 'ttf', 'otf'],
+	application: ['pdf', 'zip', 'json', 'xml']
+}
+
+// --------- ALIASES ---------
+
+const ALIASES = {
+	'jpg': 'jpeg',
+	'jpeg': 'jpg',
+	'm4a': 'mp4',
+	'mp4': 'm4a',
+	'tif': 'tiff',
+	'tiff': 'tif'
+}
+
+export const NormaliseAccept = (input) => {
+	if (!input) return []
+	
+	const raw = Array.isArray(input) ? input : input.split(/[,\s]+/)
+	const extensions = new Set()
+
+	raw
+		.map(item => item.trim().toLowerCase())
+		.filter(Boolean)
+		.forEach(item => {
+			let current = []
+
+			// 1. Handle Wildcards (e.g., image/*)
+			if (item.includes('/*') || (item.includes('/') && item.endsWith('/'))) {
+				const cat = item.split('/')[0]
+				if (BUCKETS[cat]) current.push(...BUCKETS[cat])
+			} 
+			
+			// 2. Handle Specific Mimes (e.g., image/png -> png)
+			else if (item.includes('/')) {
+				current.push(item.split('/').pop())
+			}
+
+			// 3. Handle Extensions (e.g., .jpg -> jpg)
+			else if (item.includes('.')) {
+				current.push(item.split('.').pop())
+			}
+
+			// 4. Fallback (e.g., "png")
+			else {
+				current.push(item)
+			}
+
+			// FINAL PASS: add found items + their aliases to the Set
+			
+			current.forEach(ext => {
+				extensions.add(ext)
+				if (ALIASES[ext]) extensions.add(ALIASES[ext])
+			})
+		})
+
+	return Array.from(extensions)
+}

package/lib/helpers/_Yargs.js

@@ -0,0 +1,328 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//               YARGS                  //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+import { Obj, isArr, isNum, isBool } from '../inputs/index.js'
+import { NormaliseAccept } from './_Parsers.js'
+
+import { CreateLogger } from '../logger/index.js'
+const { SAY, ERR, HMM, HUH } = CreateLogger( import.meta.url )
+
+
+async function LoadYargs() {
+
+	if (!globalThis.yargsLib || !globalThis.yargsHideBin) {
+		try {
+			globalThis.yargsLib = (await import ('yargs')).default
+			globalThis.yargsHideBin = (await import ('yargs/helpers')).hideBin
+			return true
+		} catch(err) {
+			return ERR(`YARGS UNAVAILABLE`, err)	
+		}
+	}
+}
+
+async function LoadGlobby() {
+
+	if (!globalThis.globbyLib || !globalThis.pathExtname) {
+		try {
+			globalThis.globbyLib = (await import ('globby')).globby
+			globalThis.pathExtname = (await import ('path')).extname
+			return true
+		} catch(err) {
+			return ERR(`GLOBS UNAVAILABLE`, err)	
+		}
+	}
+}
+
+async function GetYargsFiles( value, extensions ) {
+
+	try {
+
+		if (!(await LoadGlobby())) return []
+
+
+		const anything = (extensions.length === 0 || extensions.includes('*'))
+
+		const found = await globalThis.globbyLib(value, {
+			onlyFiles: true,
+			expandDirectories: false,
+			caseSensitiveMatch: false
+		})
+
+		const exts = extensions.map( ext => ext.toLowerCase().replaceAll('.',''))
+		const files = anything ? found : found.filter(file => {
+			const ext = globalThis.pathExtname(file).replaceAll('.','')
+			return exts.includes(ext)
+		})
+
+		if (files.length === 0) ERR('NO FILES', value)
+
+		return files
+
+	} catch (err) {
+		ERR('FILES ERROR:', err.message)
+		return []
+	}
+}
+
+export function GetYargsType( type ) {
+	if (isNum(type)) return 'number'
+	if (isBool(type)) return 'boolean'
+	return 'string'
+}
+
+
+export function GetParsedYargsOptions( agOptions, aliasStore = [] ) {
+
+	const options = {}
+
+	for (const [key, def] of Object.entries( agOptions )) {
+
+		const label = def?.label || key
+		let alias = label[0]
+		let counter = 1
+
+		while (aliasStore.includes(alias) && counter < 4) {
+			alias = label.substring(0,counter++)
+		}
+
+		if (aliasStore.includes(alias)) {
+			HMM('CANNOT GENERATE ALIAS FOR:', key)
+			alias = null
+		} else {
+			aliasStore.push(alias)
+		}
+
+		options[key] = ConvertYargsProperty( def, {
+			alias: alias,
+			demandOption: def.required || false,
+		})
+	}
+
+	return options
+}
+
+export function ConvertYargsProperty( def, override = {} ) {
+
+	const array = def.gui == 'files' || isArr(def.type)
+
+	return Object.assign({
+		array,
+		describe: def.description,
+		type: GetYargsType(def.type),
+		coerce: def.oncheck,
+		default: def.default,
+		accept: NormaliseAccept( def.accept )
+	}, override)
+}
+
+
+export function YargsProcessWorkaround() {
+
+	// YARGS HACK (MINIMUM POSITIONAL ARGUMENTS)
+
+	let index = process.argv.length
+	for (let i = 0; i < process.argv.length; i++) {
+		const arg = process.argv[i]
+		if (arg.startsWith('--')) index = i
+	}
+	process.argv.splice(index, 0, 'run')
+}
+
+export class YargsCommand {
+
+	command = '$0'
+	description = 'N/A'
+	version = 'N/A'
+	positionals = {}
+	options = {}
+
+	$positionals = {}
+	$options = {}
+	$aliasStore = []
+
+	constructor( { positionals, options = {}, description = 'N/A', version = 'N/A' } ) {
+
+
+		this.description = description
+		this.version = version
+
+		// --------- OPTIONS ---------
+
+		this.$options = Obj( options ).properties
+		this.options = GetParsedYargsOptions( this.$options, this.$aliasStore )
+
+		// --------- POSITIONALS ---------
+
+		this.$positionals = Obj( positionals ).properties
+		const posKeys = Object.keys( this.$positionals )
+		const strArray = []
+
+		for (let i = 0; i < posKeys.length; i++) {
+
+			const key = posKeys[i]
+			const def = this.$positionals[key]
+
+			const array = def.gui == 'files' || isArr(def.type)
+			const required = i < posKeys.length - 1 || def.required
+
+			strArray.push( required ? '<' : '[' )
+			strArray.push( key )
+			if (array) strArray.push( '..' )
+			strArray.push( required ? '>' : ']' )
+			strArray.push( ' ' )
+
+			this.positionals[key] = ConvertYargsProperty( def, {
+				array: array,
+				demandOption: required,
+			})
+		}
+
+		this.command = strArray.join('')
+
+	}
+
+	async run( runCallback = async yargsData => {} ) {
+
+		if (!(await LoadYargs())) return
+
+		YargsProcessWorkaround()
+
+		const args = globalThis.yargsHideBin( process.argv )
+		const instance = globalThis.yargsLib( args )
+
+		instance.command(
+			this.command,
+			this.description,
+			yargsData => {
+				const positionals = Object.entries(this.positionals)
+				for (const [key, def] of positionals) {
+					yargsData.positional(key, def)
+				}
+			},
+			async yargsData => {
+
+				const lookup = ['positionals']
+				for (const id of lookup) {
+					const keys = Object.keys(this[id])
+					for (const key of keys) {
+						const def = this[id][key]
+						if (def.array && yargsData[key]) {
+							yargsData[key] = await GetYargsFiles( yargsData[key], def.accept )
+						}
+					}
+				}
+
+				await runCallback( yargsData )
+
+			}
+		)
+
+		if (this.options) instance.options(this.options)
+
+		instance.strict()
+		instance.recommendCommands()
+
+		instance.help()
+		instance.alias('h', 'help')
+		instance.version(this.version)
+
+		return await instance.parse()
+
+	}
+}
+
+
+export class YargsCLI {
+
+	options = null
+	description = 'N/A'
+	version = 'N/A'
+
+	$aliasStore = []
+	$options = {}
+	$commands = {}
+
+	constructor( { commands, options = {}, description = 'N/A', version = 'N/A' } ) {
+
+		if (typeof commands != 'object') throw Error('no commands defined')
+		if (!description) HMM('no description defined (recommended)')
+		if (!version) HMM('no version defined (recommended)')
+
+		this.description = description
+		this.version = version
+
+		// --------- OPTIONS ---------
+
+		this.$options = Obj( options ).properties
+		this.options = GetParsedYargsOptions( this.$options, this.$aliasStore )
+
+		// --------- COMMANDS ---------
+
+		this.$commands = commands
+
+	}
+
+	async run( runCallback = async (cmdKey, yargsData) => {} ) {
+
+		if (!(await LoadYargs())) return
+
+		// YargsProcessWorkaround()
+
+
+		const args = globalThis.yargsHideBin( process.argv )
+		const instance = globalThis.yargsLib( args )
+
+		for (const [cmdKey, cmdObj] of Object.entries(this.$commands)) {
+
+			instance.command(
+				`${cmdKey} ${cmdObj.command}`.trim(),
+				cmdObj.description,
+				yargsData => {
+					const positionals = Object.entries(cmdObj.positionals)
+					for (const [key, def] of positionals) yargsData.positional(key, def)
+					const options = Object.entries(cmdObj.options)
+					for (const [key, def] of options) yargsData.option(key, def)
+				},
+				async yargsData => {
+
+					const lookup = [ cmdObj.positionals ]
+
+					for (const obj of lookup) {
+						const keys = Object.keys(obj)
+						for (const key of keys) {
+							const def = obj[key]
+							if (def.array && yargsData[key]) {
+								yargsData[key] = await GetYargsFiles( yargsData[key], def.accept )
+							}
+						}
+					}
+
+					await runCallback( cmdKey, yargsData )
+
+				})
+		}
+
+		if (this.options) instance.options(this.options)
+
+		instance.demandCommand(1, 'You must provide a valid command')
+		instance.strict()
+		instance.recommendCommands()
+
+		instance.help()
+		instance.alias('h', 'help')
+		instance.version(this.version)
+
+		return await instance.parse()
+	}
+
+
+}
+
+
+

package/lib/helpers/index.js

@@ -0,0 +1,9 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//               HELPERS                //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+export * from './_Yargs.js'

package/lib/index.js

@@ -0,0 +1,11 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//              AGNOSTIC                //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+export * from './helpers/index.js'
+export * from './inputs/index.js'
+export * from './specification/index.js'

package/lib/inputs/_Callers.js

@@ -0,0 +1,122 @@
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//                CALLER                //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+import { Properties } from './../specification/index.js'
+
+const META_PROPS = ['options', 'config', 'extra', 'custom', 'props']
+
+export function Caller( data ) {
+
+	let output = {}
+
+	const WriteProp = (key, value, otherKey) => {
+		if (output[key] != null) {
+			if (!output.misc) output.misc = {}
+			output.misc[otherKey || key] = value
+		} else {
+			output[key] = value
+		}
+	}
+
+	const AddProp = ( inputKey, inputValue ) => {
+
+		for (const [outputKey, spec] of Object.entries(Properties)) {
+			if (inputKey == outputKey) {
+				WriteProp( outputKey, inputValue )
+				continue
+			} else {
+				for (const otherKey of [outputKey, ...(spec.keys || [])]) {
+					if (inputKey.includes(otherKey.replace(/[_-]/g, ''))) {
+						WriteProp( outputKey, inputValue, otherKey )
+						continue
+					}
+				}
+			}
+		}
+	}
+
+	const ExtractProps = ( data ) => {
+
+		for (let [key,value] of Object.entries(data)) {
+
+			key = key.toLowerCase() // controversial
+
+			// SPLIT FOR OPTIONS
+
+			if (key.includes(':')) {
+				const [sub1, sub2] = key.split(':')
+				AddProp(sub2, value)
+			}
+
+			// SEARCH FOR OPTIONS
+
+			for (const name of META_PROPS) {
+				if (key.includes(name) && typeof value == 'object') {
+					ExtractProps(value)
+					continue
+				}
+			}
+
+			if (value != null) AddProp( key,value )
+
+		}
+	}
+
+	ExtractProps( data )
+
+	return data
+}
+
+//////////////////////////////////////////
+//                                      //
+//                                      //
+//            TYPE CALLERS              //
+//                                      //
+//                                      //
+//////////////////////////////////////////
+
+
+/** @type {typeof MinMaxCaller} */
+export function MinMaxCaller( value, min, max, schema ) {
+	const property = Caller({ ...schema, default: value, min, max })
+	return property 
+}
+
+/** @type {typeof DefaultCaller} */
+export function DefaultCaller( value, schema ) {
+	const property = Caller({ ...schema, default: value })
+	return property
+}
+
+/** @type {typeof EnumCaller} */
+export function EnumCaller( value, enumOptions, schema ) {
+	return Caller( {...schema, default: value, enum: enumOptions } )
+}
+
+/** @type {typeof ObjCaller} */
+export function ObjCaller( properties, schema) {
+	const objProperty = Caller({ ...schema, properties })
+	let index = 0
+	for (let [key,prop] of Object.entries(objProperty.properties)) {
+		prop.key = key
+		prop.index = index++
+	}
+	return objProperty
+}
+
+/** @type {typeof ArrCaller} */
+export function ArrCaller(value, items, schema) {
+	const arrProperty = Caller({ ...schema, default: value, items })
+	return arrProperty
+}
+
+/** @type {typeof EventCaller} */
+export function EventCaller( event, schema ) {
+	const eventProperty = Caller({ ...schema, onupdate: event })
+	return eventProperty
+}

package/lib/inputs/_Checker.js

@@ -0,0 +1,3 @@
+
+
+// something here for actual type checker, if adding express stuff, use safety lib