@stefanobalocco/jfsmrouter 2.0.0

package/jFSMRouter.js

@@ -0,0 +1,398 @@
+class jFSMRouter {
+    static _instance;
+    static get instance() {
+        return (jFSMRouter._instance ??= new jFSMRouter(window));
+    }
+    _regexDuplicatePathId = /\/(:\w+)(?:\[(?:09|AZ|AZ09)])?\/(?:.+\/)?(\1)(?:\[(?:09|AZ|AZ09)])?(?:\/|$)/g;
+    _regexSearchVariables = /(?<=^|\/):(\w+)(?:\[(09|AZ|AZ09)])?(?=\/|$)/g;
+    _routes = [];
+    _routeFunction403;
+    _routeFunction404;
+    _routeFunction500;
+    _routing = false;
+    _queue = [];
+    _inTransition = false;
+    _currentState;
+    _states = {};
+    _transitions = {};
+    _window;
+    constructor(window) {
+        this._window = window;
+        this._window.addEventListener("hashchange", this.checkHash.bind(this));
+    }
+    static _CheckRouteEquivalence(path1, path2) {
+        const generateVariants = (path) => {
+            let returnValue = [path];
+            if (path.includes(':AZ09')) {
+                returnValue.push(...generateVariants(path.replace(/:AZ09/, ':AZ')), ...generateVariants(path.replace(/:AZ09/, ':09')));
+            }
+            return returnValue;
+        };
+        const variants = new Set(generateVariants(path1));
+        return [...generateVariants(path2)].some(x => variants.has(x));
+    }
+    stateAdd(state) {
+        let returnValue = false;
+        if (!this._states[state]) {
+            this._states[state] = {
+                OnEnter: [],
+                OnLeave: []
+            };
+            this._transitions[state] = {};
+            if (!this._currentState) {
+                this._currentState = state;
+            }
+            returnValue = true;
+        }
+        return returnValue;
+    }
+    stateDel(state) {
+        let returnValue = false;
+        if (this._states[state]) {
+            delete this._states[state];
+            if (this._transitions[state]) {
+                delete this._transitions[state];
+            }
+            for (const tmpState in this._transitions) {
+                if (this._transitions[tmpState][state]) {
+                    delete this._transitions[tmpState][state];
+                }
+            }
+            returnValue = true;
+        }
+        return returnValue;
+    }
+    stateOnEnterAdd(state, func) {
+        let returnValue = false;
+        if (this._states[state] && !this._states[state].OnEnter.includes(func)) {
+            this._states[state].OnEnter.push(func);
+            returnValue = true;
+        }
+        return returnValue;
+    }
+    stateOnEnterDel(state, func) {
+        let returnValue = false;
+        if (this._states[state]) {
+            const position = this._states[state].OnEnter.indexOf(func);
+            if (-1 !== position) {
+                this._states[state].OnEnter.splice(position, 1);
+                returnValue = true;
+            }
+        }
+        return returnValue;
+    }
+    stateOnLeaveAdd(state, func) {
+        let returnValue = false;
+        if (this._states[state] && !this._states[state].OnLeave.includes(func)) {
+            this._states[state].OnLeave.push(func);
+            returnValue = true;
+        }
+        return returnValue;
+    }
+    stateOnLeaveDel(state, func) {
+        let returnValue = false;
+        if (this._states[state]) {
+            const position = this._states[state].OnLeave.indexOf(func);
+            if (-1 !== position) {
+                this._states[state].OnLeave.splice(position, 1);
+                returnValue = true;
+            }
+        }
+        return returnValue;
+    }
+    transitionAdd(from, to) {
+        let returnValue = false;
+        if (this._states[from] && this._states[to] && !this._transitions[from][to]) {
+            this._transitions[from][to] = {
+                OnBefore: [],
+                OnAfter: []
+            };
+            returnValue = true;
+        }
+        return returnValue;
+    }
+    transitionDel(from, to) {
+        let returnValue = false;
+        if (this._states[from] && this._states[to] && this._transitions[from][to]) {
+            delete this._transitions[from][to];
+            returnValue = true;
+        }
+        return returnValue;
+    }
+    transitionOnBeforeAdd(from, to, func) {
+        let returnValue = false;
+        if (this._states[from] && this._states[to] && this._transitions[from][to]) {
+            this._transitions[from][to].OnBefore.push(func);
+            returnValue = true;
+        }
+        return returnValue;
+    }
+    transitionOnBeforeDel(from, to, func) {
+        let returnValue = false;
+        if (this._states[from] && this._states[to] && this._transitions[from][to]) {
+            const pos = this._transitions[from][to].OnBefore.indexOf(func);
+            if (-1 !== pos) {
+                this._transitions[from][to].OnBefore.splice(pos, 1);
+                returnValue = true;
+            }
+        }
+        return returnValue;
+    }
+    transitionOnAfterAdd(from, to, func) {
+        let returnValue = false;
+        if (this._states[from] && this._states[to] && this._transitions[from][to]) {
+            this._transitions[from][to].OnAfter.push(func);
+            returnValue = true;
+        }
+        return returnValue;
+    }
+    transitionOnAfterDel(from, to, func) {
+        let returnValue = false;
+        if (this._states[from] && this._states[to] && this._transitions[from][to]) {
+            const pos = this._transitions[from][to].OnAfter.indexOf(func);
+            if (-1 !== pos) {
+                this._transitions[from][to].OnAfter.splice(pos, 1);
+                returnValue = true;
+            }
+        }
+        return returnValue;
+    }
+    get state() {
+        return this._currentState;
+    }
+    async stateSet(nextState) {
+        let returnValue = false;
+        if (!this._inTransition) {
+            this._inTransition = true;
+            if (this._currentState && this._states[nextState] && this._transitions[this._currentState] && this._transitions[this._currentState][nextState]) {
+                returnValue = true;
+                let cFL = this._transitions[this._currentState][nextState].OnBefore.length;
+                for (let iFL = 0; (returnValue && (iFL < cFL)); iFL++) {
+                    if ('function' === typeof this._transitions[this._currentState][nextState].OnBefore[iFL]) {
+                        let tmpValue = null;
+                        if ('AsyncFunction' === this._transitions[this._currentState][nextState].OnBefore[iFL].constructor.name) {
+                            tmpValue = await this._transitions[this._currentState][nextState].OnBefore[iFL]();
+                        }
+                        else {
+                            tmpValue = this._transitions[this._currentState][nextState].OnBefore[iFL]();
+                        }
+                        returnValue = (false !== tmpValue);
+                    }
+                }
+                if (returnValue) {
+                    cFL = this._states[this._currentState].OnLeave.length;
+                    for (let iFL = 0; iFL < cFL; iFL++) {
+                        if ('function' === typeof this._states[this._currentState].OnLeave[iFL]) {
+                            if ('AsyncFunction' === this._states[this._currentState].OnLeave[iFL].constructor.name) {
+                                await this._states[this._currentState].OnLeave[iFL](this._currentState, nextState);
+                            }
+                            else {
+                                this._states[this._currentState].OnLeave[iFL](this._currentState, nextState);
+                            }
+                        }
+                    }
+                    let previousState = this._currentState;
+                    this._currentState = nextState;
+                    cFL = this._transitions[previousState][this._currentState].OnAfter.length;
+                    for (let iFL = 0; iFL < cFL; iFL++) {
+                        if ('function' === typeof this._transitions[previousState][this._currentState].OnAfter[iFL]) {
+                            if ('AsyncFunction' === this._transitions[previousState][this._currentState].OnAfter[iFL].constructor.name) {
+                                await this._transitions[previousState][this._currentState].OnAfter[iFL]();
+                            }
+                            else {
+                                this._transitions[previousState][this._currentState].OnAfter[iFL]();
+                            }
+                        }
+                    }
+                    cFL = this._states[this._currentState].OnEnter.length;
+                    for (let iFL = 0; iFL < cFL; iFL++) {
+                        if ('function' === typeof this._states[this._currentState].OnEnter[iFL]) {
+                            if ('AsyncFunction' === this._states[this._currentState].OnEnter[iFL].constructor.name) {
+                                await this._states[this._currentState].OnEnter[iFL](this._currentState, previousState);
+                            }
+                            else {
+                                this._states[this._currentState].OnEnter[iFL](this._currentState, previousState);
+                            }
+                        }
+                    }
+                }
+            }
+            this._inTransition = false;
+        }
+        return returnValue;
+    }
+    checkTransition(nextState) {
+        return !!(!this._inTransition && this._currentState && this._states[nextState] && this._transitions[this._currentState] && this._transitions[this._currentState][nextState]);
+    }
+    routeSpecialAdd(code, routeFunction) {
+        let returnValue = false;
+        switch (code) {
+            case 403: {
+                this._routeFunction403 = routeFunction;
+                returnValue = true;
+                break;
+            }
+            case 404: {
+                this._routeFunction404 = routeFunction;
+                returnValue = true;
+                break;
+            }
+            case 500: {
+                this._routeFunction500 = routeFunction;
+                returnValue = true;
+                break;
+            }
+            default: {
+                throw new RangeError();
+            }
+        }
+        return returnValue;
+    }
+    routeAdd(validState, path, routeFunction, available, routeFunction403) {
+        let returnValue = false;
+        if (this._states[validState]) {
+            if (path.match(this._regexDuplicatePathId)) {
+                throw new SyntaxError('Duplicate path id');
+            }
+            else {
+                let weight = 0;
+                const regex = new RegExp('^' + path.replace(this._regexSearchVariables, function (_unused, name, type) {
+                    let returnValue = '(?<' + name + '>[';
+                    switch (type) {
+                        case '09': {
+                            returnValue += '\\d';
+                            break;
+                        }
+                        case 'AZ': {
+                            returnValue += 'a-zA-Z';
+                            break;
+                        }
+                        case 'AZ09':
+                        default: {
+                            returnValue += 'a-zA-Z\\d';
+                        }
+                    }
+                    returnValue += ']+)';
+                    return returnValue;
+                }).replace(/\//g, '\\\/') + '$');
+                const reducedPath = path.replace(this._regexSearchVariables, (_, __, component) => `:${component ?? 'AZ09'}`);
+                const paths = path.split('/');
+                const cFL = paths.length;
+                for (let iFL = 0; iFL < cFL; iFL++) {
+                    if (!paths[iFL].startsWith(':')) {
+                        weight += 2 ** (cFL - iFL - 1);
+                    }
+                }
+                if (!this._routes.find((route) => jFSMRouter._CheckRouteEquivalence(reducedPath, route.path))) {
+                    this._routes.push({
+                        path: reducedPath,
+                        validState: validState,
+                        match: regex,
+                        weight: weight,
+                        routeFunction: routeFunction,
+                        available: available,
+                        routeFunction403: routeFunction403
+                    });
+                    this._routes.sort((a, b) => ((a.weight > b.weight) ? -1 : ((b.weight > a.weight) ? 1 : 0)));
+                    returnValue = true;
+                }
+            }
+        }
+        else {
+            throw new SyntaxError('Non-existent state');
+        }
+        return returnValue;
+    }
+    routeDel(path) {
+        let returnValue = false;
+        if (!path.match(this._regexDuplicatePathId)) {
+            const reducedPath = path.replace(this._regexSearchVariables, (_, __, component) => `:${component ?? 'AZ09'}`);
+            const index = this._routes.findIndex((route) => jFSMRouter._CheckRouteEquivalence(reducedPath, route.path));
+            if (-1 < index) {
+                this._routes.splice(index, 1);
+                returnValue = true;
+            }
+        }
+        else {
+            throw new SyntaxError('Duplicate path id');
+        }
+        return returnValue;
+    }
+    trigger(path) {
+        if ('#' + path != this._window.location.hash) {
+            this._window.location.hash = '#' + path;
+        }
+    }
+    async route(path) {
+        this._routing = true;
+        let routeFunction;
+        let routePath = '';
+        let result = null;
+        for (const route of this._routes) {
+            if ((result = route.match.exec(path))) {
+                routePath = route.path;
+                let available = true;
+                if (route.available) {
+                    if ('function' === typeof route.available) {
+                        if ('AsyncFunction' === route.available.constructor.name) {
+                            available = await route.available(routePath, path, (result.groups ?? {}));
+                        }
+                        else {
+                            available = route.available(routePath, path, (result.groups ?? {}));
+                        }
+                    }
+                    else {
+                        available = false;
+                    }
+                }
+                if (available) {
+                    if (!route.validState || (this._currentState === route.validState)) {
+                        routeFunction = route.routeFunction;
+                    }
+                    else if (this._routeFunction500) {
+                        routeFunction = this._routeFunction500;
+                    }
+                }
+                else if (route.routeFunction403) {
+                    routeFunction = route.routeFunction403;
+                }
+                else if (this._routeFunction403) {
+                    routeFunction = this._routeFunction403;
+                }
+                break;
+            }
+        }
+        if (!routeFunction && this._routeFunction404) {
+            routeFunction = this._routeFunction404;
+        }
+        if (('function' !== typeof routeFunction) && this._routeFunction500) {
+            routeFunction = this._routeFunction500;
+        }
+        if (routeFunction && ('function' === typeof routeFunction)) {
+            if ('AsyncFunction' === routeFunction.constructor.name) {
+                await routeFunction(routePath, path, (result?.groups ?? {}));
+            }
+            else {
+                routeFunction(routePath, path, (result?.groups ?? {}));
+            }
+        }
+        if (this._queue.length) {
+            await this.route(this._queue.shift());
+        }
+        else {
+            this._routing = false;
+        }
+    }
+    async checkHash() {
+        const hash = (this._window.location.hash.startsWith('#') ? this._window.location.hash.substring(1) : '');
+        if ('' != hash) {
+            if (this._routing) {
+                this._queue.push(hash);
+            }
+            else {
+                await this.route(hash);
+            }
+        }
+    }
+}
+export default jFSMRouter.instance;

package/jFSMRouter.min.js

@@ -0,0 +1 @@
+class t{static t;static get instance(){return t.t??=new t(window)}i=/\/(:\w+)(?:\[(?:09|AZ|AZ09)])?\/(?:.+\/)?(\1)(?:\[(?:09|AZ|AZ09)])?(?:\/|$)/g;h=/(?<=^|\/):(\w+)(?:\[(09|AZ|AZ09)])?(?=\/|$)/g;o=[];u;l;A;p=!1;Z=[];_=!1;O;F={};D={};k;constructor(t){this.k=t,this.k.addEventListener("hashchange",this.checkHash.bind(this))}static S(t,i){const s=t=>{let i=[t];return t.includes(":AZ09")&&i.push(...s(t.replace(/:AZ09/,":AZ")),...s(t.replace(/:AZ09/,":09"))),i},e=new Set(s(t));return[...s(i)].some(t=>e.has(t))}stateAdd(t){let i=!1;return this.F[t]||(this.F[t]={OnEnter:[],OnLeave:[]},this.D[t]={},this.O||(this.O=t),i=!0),i}stateDel(t){let i=!1;if(this.F[t]){delete this.F[t],this.D[t]&&delete this.D[t];for(const i in this.D)this.D[i][t]&&delete this.D[i][t];i=!0}return i}stateOnEnterAdd(t,i){let s=!1;return this.F[t]&&!this.F[t].OnEnter.includes(i)&&(this.F[t].OnEnter.push(i),s=!0),s}stateOnEnterDel(t,i){let s=!1;if(this.F[t]){const e=this.F[t].OnEnter.indexOf(i);-1!==e&&(this.F[t].OnEnter.splice(e,1),s=!0)}return s}stateOnLeaveAdd(t,i){let s=!1;return this.F[t]&&!this.F[t].OnLeave.includes(i)&&(this.F[t].OnLeave.push(i),s=!0),s}stateOnLeaveDel(t,i){let s=!1;if(this.F[t]){const e=this.F[t].OnLeave.indexOf(i);-1!==e&&(this.F[t].OnLeave.splice(e,1),s=!0)}return s}transitionAdd(t,i){let s=!1;return this.F[t]&&this.F[i]&&!this.D[t][i]&&(this.D[t][i]={OnBefore:[],OnAfter:[]},s=!0),s}transitionDel(t,i){let s=!1;return this.F[t]&&this.F[i]&&this.D[t][i]&&(delete this.D[t][i],s=!0),s}transitionOnBeforeAdd(t,i,s){let e=!1;return this.F[t]&&this.F[i]&&this.D[t][i]&&(this.D[t][i].OnBefore.push(s),e=!0),e}transitionOnBeforeDel(t,i,s){let e=!1;if(this.F[t]&&this.F[i]&&this.D[t][i]){const h=this.D[t][i].OnBefore.indexOf(s);-1!==h&&(this.D[t][i].OnBefore.splice(h,1),e=!0)}return e}transitionOnAfterAdd(t,i,s){let e=!1;return this.F[t]&&this.F[i]&&this.D[t][i]&&(this.D[t][i].OnAfter.push(s),e=!0),e}transitionOnAfterDel(t,i,s){let e=!1;if(this.F[t]&&this.F[i]&&this.D[t][i]){const h=this.D[t][i].OnAfter.indexOf(s);-1!==h&&(this.D[t][i].OnAfter.splice(h,1),e=!0)}return e}get state(){return this.O}async stateSet(t){let i=!1;if(!this._){if(this._=!0,this.O&&this.F[t]&&this.D[this.O]&&this.D[this.O][t]){i=!0;let s=this.D[this.O][t].OnBefore.length;for(let e=0;i&&e<s;e++)if("function"==typeof this.D[this.O][t].OnBefore[e]){let s=null;s="AsyncFunction"===this.D[this.O][t].OnBefore[e].constructor.name?await this.D[this.O][t].OnBefore[e]():this.D[this.O][t].OnBefore[e](),i=!1!==s}if(i){s=this.F[this.O].OnLeave.length;for(let i=0;i<s;i++)"function"==typeof this.F[this.O].OnLeave[i]&&("AsyncFunction"===this.F[this.O].OnLeave[i].constructor.name?await this.F[this.O].OnLeave[i](this.O,t):this.F[this.O].OnLeave[i](this.O,t));let i=this.O;this.O=t,s=this.D[i][this.O].OnAfter.length;for(let t=0;t<s;t++)"function"==typeof this.D[i][this.O].OnAfter[t]&&("AsyncFunction"===this.D[i][this.O].OnAfter[t].constructor.name?await this.D[i][this.O].OnAfter[t]():this.D[i][this.O].OnAfter[t]());s=this.F[this.O].OnEnter.length;for(let t=0;t<s;t++)"function"==typeof this.F[this.O].OnEnter[t]&&("AsyncFunction"===this.F[this.O].OnEnter[t].constructor.name?await this.F[this.O].OnEnter[t](this.O,i):this.F[this.O].OnEnter[t](this.O,i))}}this._=!1}return i}checkTransition(t){return!!(!this._&&this.O&&this.F[t]&&this.D[this.O]&&this.D[this.O][t])}routeSpecialAdd(t,i){let s=!1;switch(t){case 403:this.u=i,s=!0;break;case 404:this.l=i,s=!0;break;case 500:this.A=i,s=!0;break;default:throw new RangeError}return s}routeAdd(i,s,e,h,n){let r=!1;if(!this.F[i])throw new SyntaxError("Non-existent state");if(s.match(this.i))throw new SyntaxError("Duplicate path id");{let a=0;const o=new RegExp("^"+s.replace(this.h,function(t,i,s){let e="(?<"+i+">[";switch(s){case"09":e+="\\d";break;case"AZ":e+="a-zA-Z";break;default:e+="a-zA-Z\\d"}return e+="]+)",e}).replace(/\//g,"\\/")+"$"),c=s.replace(this.h,(t,i,s)=>`:${s??"AZ09"}`),u=s.split("/"),l=u.length;for(let t=0;t<l;t++)u[t].startsWith(":")||(a+=2**(l-t-1));this.o.find(i=>t.S(c,i.path))||(this.o.push({path:c,validState:i,match:o,weight:a,routeFunction:e,available:h,routeFunction403:n}),this.o.sort((t,i)=>t.weight>i.weight?-1:i.weight>t.weight?1:0),r=!0)}return r}routeDel(i){let s=!1;if(i.match(this.i))throw new SyntaxError("Duplicate path id");{const e=i.replace(this.h,(t,i,s)=>`:${s??"AZ09"}`),h=this.o.findIndex(i=>t.S(e,i.path));-1<h&&(this.o.splice(h,1),s=!0)}return s}trigger(t){"#"+t!=this.k.location.hash&&(this.k.location.hash="#"+t)}async route(t){let i;this.p=!0;let s="",e=null;for(const h of this.o)if(e=h.match.exec(t)){s=h.path;let n=!0;h.available&&(n="function"==typeof h.available&&("AsyncFunction"===h.available.constructor.name?await h.available(s,t,e.groups??{}):h.available(s,t,e.groups??{}))),n?h.validState&&this.O!==h.validState?this.A&&(i=this.A):i=h.routeFunction:h.routeFunction403?i=h.routeFunction403:this.u&&(i=this.u);break}!i&&this.l&&(i=this.l),"function"!=typeof i&&this.A&&(i=this.A),i&&"function"==typeof i&&("AsyncFunction"===i.constructor.name?await i(s,t,e?.groups??{}):i(s,t,e?.groups??{})),this.Z.length?await this.route(this.Z.shift()):this.p=!1}async checkHash(){const t=this.k.location.hash.startsWith("#")?this.k.location.hash.substring(1):"";""!=t&&(this.p?this.Z.push(t):await this.route(t))}}export default t.instance;