jj 0.1.0 → 2.0.0

package/control.js

@@ -1,74 +0,0 @@
-import { isFn, isNum } from './util.js'
-
-function parseRangeArguments(arr) {
-    if (arr.length < 2) {
-        throw new TypeError(`Expected at least 2 arguments but got ${arr}`)
-    }
-    if (!isNum(arr[0])) {
-        throw new TypeError(`The first argument must be a number but got ${arr[0]}`)
-    }
-    if (isFn(arr[1])) {
-        // range(end, fn, ...extraParams)
-        const [ end, fn, ...extraParams ] = arr
-        return { start: 0, end, step: 1, fn, extraParams }
-    } else if (isFn(arr[2])) {
-        // range(start, end, fn, ...extraParams)
-        const [ start, end, fn, ...extraParams ] = arr
-        return { start, end, step: 1, fn, extraParams }
-    } else if (isFn(arr[3])) {
-        // // range(start, end, step, fn, ...extraParams)
-        const [ start, end, step, fn, ...extraParams ] = arr
-        return { start, end, step, fn, extraParams }
-    }
-    throw new TypeError(`Which function do you want to run? Got ${arr}`)
-}
-
-export const control = {
-    /**
-     * @remark if inside the function you need to refer to the tag (exposed as `this`), just remember
-     * to use a classic function instead of an arrow function
-     */
-    if(condition, fn, ...extraParams) {
-        if (condition) {
-            return this.run(fn, ...extraParams)
-        }
-        return this
-    },
-
-    forEach(arr, fn, ...extraParams) {
-        arr.forEach(item => {
-            this.run(fn, item, ...extraParams)
-        })
-
-        return this
-    },
-
-    times(n, fn, ...extraParams) {
-        return this.range(1, n + 1, 1, fn, ...extraParams)
-    },
-
-    // range(start, end, step, fn, ...extraParams)
-    // range(start, end, fn, ...extraParams) // step = 1
-    // range(end, fn, ...extraParams) // start = 0, step = 1
-    range() {
-        const { start, end, step, fn, extraParams } = parseRangeArguments(Array.from(arguments))
-        if (!isNum(start) || !isNum(end) || !isNum(step)) {
-            throw new TypeError(`Expected numbers but got: start=${start}, end=${end}, step=${step}`)
-        }
-        if (step === 0) {
-            throw new Error(`The step cannot be zero`)
-        }
-        if ((start < end && step < 0) || (start > end && step > 0)) {
-            throw new Error(`This loop will never end: start=${start}, end=${end}, step=${step}`)
-        }
-        for (let i = start; i < end; i += step) {
-            this.run(fn, i, ...extraParams)
-        }
-        return this
-    },
-
-    run(fn, ...extraParams) {
-        fn.call(this, this, ...extraParams)
-        return this
-    },
-}

package/events.js

@@ -1,16 +0,0 @@
-export const events = {
-    on(eventName, handler) {
-        this.el.addEventListener(eventName, handler)
-        return this
-    },
-
-    once(eventName, handler) {
-        this.el.addEventListener(eventName, handler, { once: true })
-        return this
-    },
-
-    off(eventName, handler) {
-        this.el.removeEventListener(eventName, handler)
-        return this
-    }
-}

package/index.js

@@ -1,26 +0,0 @@
-export { rnd, qut, runOnce, ent, doc } from './util.js'
-export * from './unit.js'
-export * from './Selector.js'
-export * from './Tag.js'
-export * from './Router.js'
-import { win } from './win.js'
-import { startObserving, stopObserving } from './observer.js'
-
-const DOMContentLoaded = 'DOMContentLoaded'
-
-export function ready(fn) {
-    const { document: { readyState } } = window
-    if (readyState === 'complete' || readyState === 'loaded' || readyState === 'interactive') {
-        fn()
-    } else {
-        function onReady() {
-            win.off(DOMContentLoaded, onReady)
-            fn()
-        }
-        win.on(DOMContentLoaded, onReady)
-    }
-}
-
-win.on('unload', () => stopObserving())
-
-ready(() => startObserving())

package/observer.js

@@ -1,27 +0,0 @@
-// https://developer.mozilla.org/en-US/docs/Web/Guide/Events/Creating_and_triggering_events
-export const attachedEvent = new Event('attached')
-export const detachedEvent = new Event('detached')
-
-export function mutationObservationCb(mutationsList, observer) {
-    for (var mutation of mutationsList) {
-        if (mutation.type == 'childList') {
-            mutation.addedNodes.forEach(n => n.dispatchEvent(attachedEvent))
-            mutation.removedNodes.forEach(n => n.dispatchEvent(detachedEvent))
-        }
-    }
-};
-
-var mo
-
-export function startObserving(observationRoot = document.documentElement) {
-    // https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
-    mo = new MutationObserver(mutationObservationCb)
-    const config = { childList: true, subtree: true };
-    mo.observe(observationRoot, config);    
-}
-
-export function stopObserving() {
-    if (mo) {
-        mo.disconnect()
-    }
-}

package/rollup.config.js

@@ -1,25 +0,0 @@
-import { terser } from 'rollup-plugin-terser'
-import gzipPlugin from 'rollup-plugin-gzip'
-
-module.exports = {
-  input: 'index.js',
-  plugins: [
-    terser({ include: ['jj.min.js', 'esm'] }),
-    gzipPlugin()
-  ],
-  output: [
-    {
-      compact: false,
-      indent: false,
-      file: 'dist/jj.js',
-      format: 'esm'
-    },
-    {
-      compact: true,
-      indent: false,
-      sourcemap: true,
-      file: 'dist/jj.min.js',
-      format: 'esm'
-    },
-  ]
-};

package/unit.js

@@ -1,78 +0,0 @@
-import { isStr, alias } from './util.js'
-
-class Dim {
-    constructor(value, unit) {
-        if (isStr(value)) {
-            this.parse(value)
-        } else {
-            this.value = value
-            this.unit = unit
-        }
-    }
-
-    clone() {
-        return new Dim(this.value, this.unit)
-    }
-
-    parse(str) {
-        const parts = str.match(/([-+]?[0-9.]+)([%\w]*)/)
-        if (parts) {
-            const [, value, unit] = parts
-            this.value = value
-            this.unit = unit
-        }
-        throw new SyntaxError(`Could not parse ${str} as a CSS Dimention`)
-    }
-
-    toString() {
-        return `${this.value}${this.unit}`
-    }
-
-    [Symbol.toPrimitive](hint) {
-        if (hint === 'string') {
-            return this.toString()
-        }
-        return this.value
-    }
-}
-
-alias(Dim, {
-    toString: 'toJSON'
-})
-
-export function isDim(val) {
-    return val instanceof Dim
-}
-
-export function perc(num) {
-    return new Dim(num, '%')
-}
-
-export function em(num) {
-    return new Dim(num, 'em')
-}
-
-export function rem(num) {
-    return new Dim(num, 'rem')
-}
-
-export function px(num) {
-    return new Dim(num, 'px')
-}
-
-export function vh(num) {
-    return new Dim(num, 'vh')
-}
-
-export function vw(num) {
-    return new Dim(num, 'vw')
-}
-
-export function col(r, g, b, a) {
-    if (g === undefined && b === undefined && a === undefined) {
-        if (isStr(r, 1)) {
-            return `#${r}`
-        }
-    }
-    throw new Error('TODO: Use case not implemented yet')
-}

package/util.js

@@ -1,153 +0,0 @@
-export const INDENT = '    '
-export const NEWLINE = '\n'
-
-export function isArr(x) {
-    return Array.isArray(x)
-}
-
-export function arrFrom(x) {
-    return Array.from(x)
-}
-
-export function toArray(a) {
-    return isArr(a) ? a : [a]
-}
-
-export function ind(indentation, addition = 0) {
-    if (indentation < 0) {
-        return ''
-    }
-    indentation += addition
-    if (ind.cache[indentation] === undefined) {
-        ind.cache[indentation] = INDENT.repeat(indentation)
-    }
-    return ind.cache[indentation]
-}
-ind.cache = ['', INDENT]
-
-export function nl(indentation) {
-    return indentation < 0 ? '' : NEWLINE
-}
-
-export function mapKeyVal(obj, fn) {
-    return Object.entries(obj).map(([k, v]) => fn(k, v, obj))
-}
-
-export function isObj(a) {
-    return a && typeof a === 'object'
-}
-
-export function isStr(a, minLength = 0) {
-    return typeof a === 'string' && a.length >= minLength
-}
-
-export function isNum(a) {
-    return typeof a === 'number' && Number.isFinite(a)
-}
-
-export function isFn(a) {
-    return typeof a === 'function'
-}
-
-export function isBool(a) {
-    return typeof a === 'boolean'
-}
-
-export function isDef(a) {
-    return a !== undefined
-}
-
-export function camel2kebab(str) {
-    return str.replace(/([A-Z])/g, ch => '-' + ch.toLowerCase())
-}
-
-export function cssValue(v) {
-    if (isArr(v)) {
-        return v.join(' ')
-    }
-    return v
-}
-
-function embed(start, end, ...contents) {
-    return start + contents.join('') + end
-}
-
-export function par(...strArr) {
-    return embed('(', ')', ...strArr)
-}
-
-export function qut(...strArr) {
-    const str = strArr.join('').replace('"', '\\"')
-    return embed('"', '"', str)
-}
-
-export function ent(entity) {
-    if (isStr(entity)) {
-        return '&' + entity + ';'
-    } else if (isNum(entity) && Number.isInteger(entity)) {
-        return `&#${entity};`
-    }
-    throw new TypeError(`Cannot make HTML entity from ${entity}`)
-}
-
-export function sqBra(...strArr) {
-    return embed('[', ']', ...strArr)
-}
-
-export function rnd(prefix) {
-    const randomStr = Math.random().toString(36).substr(2)
-    // the resulting string should always start with a letter, otherwise it won't work as class or id
-    return isStr(prefix) ? `${prefix}-${randomStr}` : randomStr
-}
-
-export function alias(obj, aliasDic) {
-    const prt = obj.prototype
-
-    function assignTarget(dst, src) {
-        if (prt[dst] !== undefined) {
-            throw new Error(`${obj.name} already has a method called ${dst}`)
-        }
-        prt[dst] = prt[src]
-    }
-
-    mapKeyVal(aliasDic, (src, dst) => {
-        if (isArr(dst)) {
-            dst.forEach(d => assignTarget(d, src))
-        } else {
-            assignTarget(dst, src)
-        }
-    })
-}
-
-const ranOnce = Symbol('ran once flag')
-export function runOnce(fn, ...args) {
-    if (isFn(fn) && !fn[ranOnce]) {
-        fn.apply(undefined, args)
-        fn[ranOnce] = true
-    }
-}
-
-export const doc = {
-    el(tagName, ns) {
-        return isStr(ns) ? document.createElementNS(ns, tagName) : document.createElement(tagName)
-    },
-    frag() {
-        return document.createDocumentFragment()
-    },
-    text(...strArr) {
-        return document.createTextNode(String(strArr.flat().join('')))
-    },
-    comm(...strArr) {
-        return document.createComment(String(strArr.flat().join('')))
-    },
-    get body() {
-        return document.body
-    },
-    get head() {
-        return document.body.head
-    },
-}
-
-export function isComponent(obj) {
-    return isObj(obj) && isObj(obj.root)
-}

package/win.js

@@ -1,11 +0,0 @@
-import { events } from './events.js'
-
-class Window {
-    constructor(windowRef) {
-        this.el = windowRef
-    }
-}
-
-Object.assign(Window.prototype, events)
-
-export const win = new Window(window)