tungsten 0.1.6 → 0.1.24

package/dist/routing/Router.js

@@ -0,0 +1,238 @@
+// import { TungstenSimpleInternalStoreComponent } from '../Components.jsx'
+// import { TungstenError } from '../TungstenError.js'
+// import { ContentNode, ContentNodeElement, ContentNodeElementIsComponent, ContentNodeClassComponent, ContentNodeComponentIsClassComponent, ContentNodeSingle, ContentNodeSingleIsElement, ContentNodeIsElement, ContentNodeIsSingle, ContentNodeIsComponent } from '../ContentNode.js'
+// import { matchPath } from './matchPath.js'
+// import { Default404 } from './Default404.jsx'
+// import { Route, RouteProps } from './Route.js'
+// import { isClient } from '../isClient.js'
+// import { isProd } from '../isProd.js'
+// import { Match } from './Match.type.js'
+// import { isServer } from '../isServer.js'
+// import { $props, $type } from '../contentNodeSymbols.js'
+// import { debug } from './debug.js'
+// import { packageNameCapitalized } from '../settings.js'
+// import { throwError } from '../throwError.js'
+export {};
+// // we can fetch data in requests, but we can't do anything with it until render or init
+// type RouterDataFunction<T> = (location: string) => Promise<T>
+// type RouterProcessFunction<T> = (data: T) => void | Promise<void>
+// export type RouterProps<T> = {
+//     data?: RouterDataFunction<T>
+//     process?: RouterProcessFunction<T>
+//     children?: ContentNode
+// }
+// export class Router<T> extends TungstenSimpleInternalStoreComponent<RouterProps<T>, object> {
+//     staticSiteClient = false
+//     hydrated = false
+//     // the below will fail if a static site is run dynamically in production mode
+//     // another check needed to avoid this
+//     init = () => {
+//         this.staticSiteClient = (this.__instance.config.staticSite === true && isClient && isProd)
+//         //if (isClient) this.__instance.appDefaultTitle = document.title // save the current title to use a default later
+//     }
+//     componentDidHydrate = () => {
+//         debug('Router did hydrate')
+//         this.hydrated = true
+//     }
+//     componentDidMount = () => {
+//         debug('Router did mount')
+//         // would rather use this hook
+//     }
+//     componentDidUpdate = () => debug('Router did update')
+//     componentDidRender = () => debug('Router did render')
+//     content = async () => {
+//         debug('Router content')
+//         //console.log('Router content')
+//         // this will cause the component to update when the app location changes
+//         //let location = this.__internalStore.sync('location')
+//         let location = this.store.location.sync()
+//         if (this.staticSiteClient) {
+//             if (location.endsWith('/index.html')) {
+//                 location = location.slice(0, -1 * '/index.html'.length)
+//                 if (location === '') location = '/' // the index root will be empty, so set it to /
+//             } else if (location !== '/') {
+//                 location = location.slice(0, -1 * '.html'.length)
+//             }
+//         }
+//         let defaultRoute, _404Route
+//         // try the current path against each defined route
+//         // routeNode is a Route node in the children tree
+//         // this is assuming an array
+//         // should check whether we have an array, fragment, or single element instead
+//         let routeElements: ContentNodeClassComponent[] = []
+//         function routeElementFilter(el: ContentNode): el is ContentNodeClassComponent {
+//             return (
+//                 ContentNodeIsSingle(el)
+//                 && ContentNodeSingleIsElement(el)
+//                 && ContentNodeElementIsComponent(el)
+//                 && ContentNodeComponentIsClassComponent(el)
+//                 && (
+//                     el[$type] === Route
+//                     || el[$type].prototype instanceof Route
+//                 )
+//             )
+//         }
+//         const children = this.props.children
+//         if (Array.isArray(children)) {
+//             // ContentNodeSingle[]
+//             routeElements = children.filter(routeElementFilter) 
+//         } else {
+//             children
+//             if (ContentNodeSingleIsElement(children)) {
+//                 children
+//                 if (
+//                     ContentNodeElementIsComponent(children)
+//                     && ContentNodeComponentIsClassComponent(children)
+//                 ) {
+//                     //console.log('routes children is a class based element')
+//                         // Class based element
+//                     if (children[$type] instanceof Route) {
+//                             // should be a Route or descendant of Route
+//                         routeElements = [children]
+//                     }
+//                 }
+//             }
+//         }
+//         for (const routeNode of routeElements) {
+//             const type = routeNode[$type]
+//             const props = routeNode[$props] as RouteProps
+//             // see if the element is a Route element?
+//             if ( type === Route || (typeof type === 'function' && type.prototype instanceof Route) ) {
+//                 const path = props.path || props.route?.path
+//                 if (path === undefined) {
+//                     throw new TungstenError(`Route() error - Route ${type.constructor.name} has no path specified`)
+//                 }
+//                 //const path = props.path || props.route.path
+//                 // extract default or 404 routes out for later, without processing them now
+//                 if (path === 'default') {
+//                     defaultRoute = routeNode
+//                     continue
+//                 }
+//                 if (path === '404') {
+//                     _404Route = routeNode
+//                     continue
+//                 }
+//                 // match path
+//                 if ( ! path ) throw new TungstenError(`${packageNameCapitalized} error: a Route has no path attribute. Route: ${JSON.stringify(routeNode)}`)
+//                 //console.log('match path', props.path, location)
+//                 const match = matchPath(path, location)
+//                 //console.log('route match', match)
+//                 if (match !== null) {
+//                     //console.log('render route', routeNode)
+//                     return this.renderRoute(routeNode, location, match)
+//                 }
+//             }
+//         }
+//         // handle 404 and default routes
+//         if (defaultRoute) return this.renderRoute(defaultRoute, location)
+//         if (_404Route) return this.renderRoute(_404Route, location)
+//         return <Default404 />
+//     }
+//     renderRoute = async function(this: Router<T>, routeNode: ContentNodeElement, location: string, match?: Match) {
+//         //console.log('renderRoute')
+//         //// We need to properly handle whether props are on the Route object, or on the Route.route prop
+//         //// So merge these together
+//         const props = routeNode[$props] as RouteProps
+//         const routeInfo = {
+//             path: props.path || props.route?.path,
+//             content: ('children' in props) ? props.children : props.route?.content,
+//             data: props.data || props.route?.data
+//         }
+//         /*
+//         const route: PropRoute | undefined = props.route//(props.route !== undefined) ? props.route : u
+//         if (route !== undefined) {
+//             route.path = props.path
+//             for (const key of ['content', 'data']) {
+//                 if (key in props) route[key] = props[key]
+//             }
+//         }
+//         */
+//         // if only fetch data on the server, or on client side updates
+//         // !!! I don't think mounted is the correct check. What if a Router is added to the page after hydration?
+//         let routeData
+//         let routerData
+//         if (isServer || this.hydrated) {
+//             debug('seeing if we can fetch route data')
+//             debug('match', match)
+//             debug('data func', routeInfo.data)
+//             //console.log('data func', routeInfo.data)
+//             if (match !== undefined) {
+//                 // how about error handling?
+//                 //console.log('try data')
+//                     // run requests and route data at the same time
+//                 const routeDataPromise = (routeInfo.data !== undefined) ? routeInfo.data(match.params, location) : Promise.resolve(undefined)
+//                 const routerDataPromise = (this.props.data !== undefined) ? this.props.data(location) : Promise.resolve(undefined)
+//                 // await them both
+//                 if (routeInfo.data !== undefined) {
+//                     try {
+//                         routeData = await routeDataPromise  
+//                         this.__instance.routeData = routeData  
+//                     } catch (e) {
+//                         this.__instance.routeDataError = e
+//                     }
+//                 }
+//                 if (this.props.data !== undefined) {
+//                     try {
+//                         routerData = await routerDataPromise
+//                         this.__instance.routerData = routerData
+//                     } catch (e) {
+//                         this.__instance.routerDataError = e
+//                     }
+//                 }
+//                 //console.log('server: added routeData to instance')
+//                 //console.log('routeData', routeData)
+//             }
+//         } else {
+//             // has our data from requests been passed to the client?
+//             // do we need to serialize the store first?
+//             debug('assigning route data from the instance')
+//             //console.log('client: got routeData from instance')
+//             routeData = this.__instance.routeData
+//             routerData = this.__instance.routerData
+//         }
+//         if (this.props.data !== undefined && this.props.process !== undefined) {
+//             await this.props.process(routerData)
+//         }
+//         //debug('props', props)
+//         //debug('route', route)
+//         if (routeInfo.content === undefined) {
+//             throwError('Router', 
+//                 `No content found for route ${props.path}.`
+//                 + ` Provide "children" to the <Route> element, or provide a route prop that has a content field.`
+//             )
+//         }
+//         if (typeof routeInfo.content === 'function') {
+//             return routeInfo.content(routeData, match ? match.params : {}, location) //   passing the match params
+//         } else {
+//             routeNode[$props].__T_routeParams = match ? match.params : {}
+//             routeNode[$props].__T_routeData = routeData
+//             routeNode[$props].__T_location = location
+//             return routeNode
+//         }
+//         /*
+//         const content = routeInfo.content 
+//         if (typeof content === 'function') {                               // call the function contained in the Route
+//             return content(match ? match.params : {}, routeData, location) //   passing the match params
+//         } else if (                                      // if the content is a single component, 
+//             ContentNodeIsElement(content)                //   pass it the route params           
+//         ) {                                                         
+//             // mutating the content tree here should
+//             //   be fine because we will get a new
+//             //   tree if an update occurs
+//             // console.log('adding route data to props')
+//             // content.props.routeParams = match?.params
+//             // content.props.routeData = routeData                     
+//             content.routeParams = match?.params
+//             content.routeData = routeData
+//             return content
+//         } else {
+//             return content  // for text nodes, or arrays, just return the content unadulterated
+//         }
+//         */
+//     }
+// }
+// // type RouteComponentProps = {
+// //     path: string
+// //     children?: ContentNode
+// //     [key: string]: any
+// // }

package/dist/routing/Routes.d.ts

@@ -0,0 +1,17 @@
+import type { Path } from './RouteTypes.js';
+import type { RouteType } from './RouteType.js';
+export type Routes = {
+    [key in Path]: RouteType<any, any>;
+} & ({
+    'default': RouteType<any, any>;
+} | {
+    '404': RouteType<any, any>;
+});
+export type CustomRoutes<Route extends RouteType<any, any>> = {
+    [key in Path]: Route;
+} & ({
+    'default': Route;
+} | {
+    '404': Route;
+});
+//# sourceMappingURL=Routes.d.ts.map

package/dist/routing/Routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Routes.d.ts","sourceRoot":"","sources":["../../src/routing/Routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAY,MAAM,iBAAiB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,MAAM,MAAM,MAAM,GAAG;KAAG,GAAG,IAAI,IAAI,GAAG,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC;CAAE,GACzD,CACE;IAAE,SAAS,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;CAAE,GAChC;IAAE,KAAK,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;CAAE,CACnC,CAAA;AAED,MAAM,MAAM,YAAY,CAAC,KAAK,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI;KAAG,GAAG,IAAI,IAAI,GAAG,KAAK;CAAE,GACpF,CACE;IAAE,SAAS,EAAE,KAAK,CAAA;CAAE,GAClB;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,CACrB,CAAA"}

package/dist/routing/Routes.js

@@ -0,0 +1 @@
+export {};

package/dist/routing/RoutesFunction.d.ts

@@ -0,0 +1,4 @@
+import type { ReqRes } from '../ReqRes.js';
+import type { Routes } from './Routes.js';
+export type RoutesFunction = (reqRes: ReqRes | null) => Routes;
+//# sourceMappingURL=RoutesFunction.d.ts.map

package/dist/routing/RoutesFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutesFunction.d.ts","sourceRoot":"","sources":["../../src/routing/RoutesFunction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEzC,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,MAAM,CAAA"}

package/dist/routing/RoutesFunction.js

@@ -0,0 +1 @@
+export {};

package/dist/routing/RoutesWithSafeParams.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RoutesWithSafeParams.d.ts.map

package/dist/routing/RoutesWithSafeParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutesWithSafeParams.d.ts","sourceRoot":"","sources":["../../src/routing/RoutesWithSafeParams.ts"],"names":[],"mappings":""}

package/dist/routing/RoutesWithSafeParams.js

@@ -0,0 +1,51 @@
+// import { mapToObject as arrayMapToObject } from 'sxy-lib/arrays.js'
+export {};
+// import { ContentNode } from '../ContentNode.js'
+// import { RouteContentFunction } from './RouteContentFunction.js'
+// import { RouteDataFunction } from './RouteDataFunction.type.js'
+// import { RouteType } from './RouteType.js'
+// import { ParamsFromPath } from './routeParamExtraction.js'
+// import { Expand } from '../../types/helpers.js'
+// import { Path } from './Route.jsx'
+// export type RouteWithSafeParams<Key extends Path, DataType> = {
+//     path: Key,
+//     data?: RouteDataFunction<ParamsFromPath<Key>, DataType>
+//     content: ContentNode | RouteContentFunction<ParamsFromPath<Key>, DataType>
+// }
+// type RoutesWithSafeParams<Keys extends Path> = {
+//     [Key in Keys]: RouteWithSafeParams<Key, any>
+// }
+// type ArrayToObject<T extends [string, unknown][]> = {
+//     [P in T[number] as P[0]]: P[1]
+// }
+// type RoutesArrayToObject<T extends RouteWithSafeParams<any, any>[]> = {
+//     [R in T[number] as R['path']]: R
+// }
+// const a = [
+//     ['/foo', { content: null }]
+// ] satisfies [string, unknown][]
+// type O = ArrayToObject<typeof a>
+// function makeRoutes<Routes extends readonly RouteWithSafeParams<any, any>[]>(routes: Routes): Expand<RoutesArrayToObject<Routes>> {
+//     return arrayMapToObject(routes, (route => [route.path, route])) as RoutesArrayToObject<Routes> // eslint-disable-line no-type-assertion/no-type-assertion
+// }
+// // function makeRoute<Path extends string>(path: Path, route: RouteWithSafeParams<Path, any>): [Path, RouteWithSafeParams<Path, any>] {
+// //     return [path, route]
+// // }
+// const rr = [
+//     {
+//         path: '/user/:id',
+//         content: (_, { id }) => null
+//     } satisfies RouteWithSafeParams<'/user/:id', any>
+// ] as const
+// const ra = [
+//     {
+//         path: '/user/:id',
+//         content: (_, { id }) => null
+//     } satisfies RouteWithSafeParams<'/user/:id', any>
+// ] as const
+// const rrr = makeRoutes(ra)
+// const routes = {
+//     '/user/:id': {
+//         content: (_, { id }) => null
+//     }
+// } satisfies RoutesWithSafeParams<'/user/:id'>

package/dist/routing/RoutingRedirect.d.ts

@@ -0,0 +1,8 @@
+import type { RouteKey } from './RouteTypes.js';
+export type RedirectCode = 301 | 302 | 303 | 307 | 308;
+export declare class RoutingRedirect {
+    to: RouteKey;
+    code: RedirectCode;
+    constructor(to: RouteKey, code?: RedirectCode);
+}
+//# sourceMappingURL=RoutingRedirect.d.ts.map

package/dist/routing/RoutingRedirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutingRedirect.d.ts","sourceRoot":"","sources":["../../src/routing/RoutingRedirect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AAE/C,MAAM,MAAM,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;AAEtD,qBAAa,eAAe;IACxB,EAAE,EAAE,QAAQ,CAAA;IACZ,IAAI,EAAE,YAAY,CAAA;gBACN,EAAE,EAAE,QAAQ,EAAE,IAAI,GAAE,YAAkB;CAIrD"}

package/dist/routing/RoutingRedirect.js

@@ -0,0 +1,11 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export class RoutingRedirect {
+  constructor(to, code = 302) {
+    _defineProperty(this, "to", void 0);
+    _defineProperty(this, "code", void 0);
+    this.to = to;
+    this.code = code;
+  }
+}

package/dist/routing/compareRequestToRegex.d.ts

@@ -0,0 +1,9 @@
+type CompareResult = {
+    success: boolean;
+    params: {
+        [key: string]: string;
+    };
+};
+export declare function compareRequestToRegex(request: string, regex: RegExp, keys: string[]): CompareResult;
+export {};
+//# sourceMappingURL=compareRequestToRegex.d.ts.map

package/dist/routing/compareRequestToRegex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareRequestToRegex.d.ts","sourceRoot":"","sources":["../../src/routing/compareRequestToRegex.ts"],"names":[],"mappings":"AAIA,KAAK,aAAa,GAAG;IACjB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;CACpC,CAAA;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAYnG"}

package/dist/routing/compareRequestToRegex.js

@@ -0,0 +1,10 @@
+import { arrays } from 'sxy-lib';
+export function compareRequestToRegex(request, regex, keys) {
+  const matches = regex.exec(request);
+  const success = matches !== null;
+  const params = success ? arrays.mapToObject(keys, (key, index) => [key, matches[index + 1]]) : arrays.mapToObject(keys, key => [key, undefined]);
+  return {
+    success,
+    params: params // working around the TS issues with records/mapped types. [key: string]: A and [Key in Type]?: A are inconsistent, second turns A into A | undefined. come back to this later
+  };
+}

package/dist/routing/compareRequestToRegex.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compareRequestToRegex.sxyt.d.ts.map

package/dist/routing/compareRequestToRegex.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareRequestToRegex.sxyt.d.ts","sourceRoot":"","sources":["../../src/routing/compareRequestToRegex.sxyt.ts"],"names":[],"mappings":""}

package/dist/routing/compareRequestToRegex.sxyt.js

@@ -0,0 +1,65 @@
+import { describe } from 'sxy-test-runner';
+import { expect } from 'chai';
+import { objects } from 'sxy-lib';
+import { compareRequestToRegex } from "./compareRequestToRegex.js";
+import { patternToRegex } from "./patternToRegex.js";
+describe('routing/compareRequestToRegex()', ({
+  it
+}) => {
+  it(`/foo matches /foo no params`, () => {
+    const pattern = '/foo';
+    const request = '/foo';
+    const {
+      regex,
+      keys
+    } = patternToRegex(pattern);
+    const {
+      success,
+      params
+    } = compareRequestToRegex(request, regex, keys);
+    success.should.equal(true);
+    objects.count(params).should.equal(0);
+  });
+  it(`/foo does not match /foo/bar`, () => {
+    const pattern = '/foo';
+    const request = '/foo/bar';
+    const {
+      regex,
+      keys
+    } = patternToRegex(pattern);
+    const {
+      success,
+      params
+    } = compareRequestToRegex(request, regex, keys); // eslint-disable-line @typescript-eslint/no-unused-vars
+    success.should.equal(false);
+  });
+  it(`/foo/:bar matches /foo/bing with the params { bar: 'bing' }"`, () => {
+    const pattern = '/foo/:bar';
+    const request = '/foo/bing';
+    const {
+      regex,
+      keys
+    } = patternToRegex(pattern);
+    const c = compareRequestToRegex(request, regex, keys);
+    const {
+      success,
+      params
+    } = c;
+    success.should.equal(true);
+    objects.count(params).should.equal(1);
+    expect(params.bar).to.equal('bing');
+  });
+  it(`/foo/:bar does not match /foo/"`, () => {
+    const pattern = '/foo/:bar';
+    const request = '/foo/';
+    const {
+      regex,
+      keys
+    } = patternToRegex(pattern);
+    const {
+      success,
+      params
+    } = compareRequestToRegex(request, regex, keys); // eslint-disable-line @typescript-eslint/no-unused-vars
+    success.should.equal(false);
+  });
+});

package/dist/routing/debug.d.ts

@@ -0,0 +1,2 @@
+export declare function debug(...texts: unknown[]): void;
+//# sourceMappingURL=debug.d.ts.map

package/dist/routing/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/routing/debug.ts"],"names":[],"mappings":"AACA,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,QAExC"}

package/dist/routing/debug.js

@@ -0,0 +1,3 @@
+export function debug(...texts) {
+  // console.log(...texts)
+}

package/dist/routing/getPathPriority.d.ts

@@ -0,0 +1,2 @@
+export declare function getPathPriority(path: `/${string}`): number;
+//# sourceMappingURL=getPathPriority.d.ts.map

package/dist/routing/getPathPriority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPathPriority.d.ts","sourceRoot":"","sources":["../../src/routing/getPathPriority.ts"],"names":[],"mappings":"AAMA,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,MAAM,EAAE,UAiGjD"}

package/dist/routing/getPathPriority.js

@@ -0,0 +1,99 @@
+import { throwError } from "../throwError.js";
+function debug(...texts) {
+  //console.log(...texts)
+}
+export function getPathPriority(path) {
+  debug('path', path);
+  let priorityString = '';
+  let mode = 'slash';
+  let paramOpenBrackets = 0;
+  let paramEscaped = false;
+  let pos = 0;
+  while (pos < path.length) {
+    const char = path[pos];
+    debug('char', char);
+    switch (mode) {
+      case 'slash':
+        {
+          if (char !== '/') throwError('getPathPriority', `parsing error, expected to find '/' at position ${pos}, instead found '${char}` + `error occurred while parsing route path ${path}`);
+          mode = 'search';
+          debug('mode: search');
+          break;
+        }
+      case 'search':
+        {
+          if (char === '/') throwError('getPathPriority', `parsing error, found '/' at position ${pos}, expecting to find any other character` + `error occurred while parsing route path ${path}`);
+          if (char === ':') {
+            mode = 'param';
+            debug('mode: param');
+            priorityString += '1';
+            debug('priorityString:', priorityString);
+            paramOpenBrackets = 0;
+            paramEscaped = false;
+          } else {
+            mode = 'segment';
+            debug('mode: segment');
+            priorityString += '2';
+            debug('priorityString:', priorityString);
+          }
+          break;
+        }
+      case 'segment':
+        {
+          if (char === '/') {
+            mode = 'search';
+            debug('mode: search');
+          }
+          break;
+        }
+      case 'param':
+        {
+          debug('paramEscaped', paramEscaped);
+          debug('paramOpenBrackets', paramOpenBrackets);
+          switch (char) {
+            case '\\':
+              {
+                paramEscaped = !paramEscaped;
+                break;
+              }
+            case '(':
+              {
+                if (!paramEscaped) paramOpenBrackets++;
+                paramEscaped = false;
+                break;
+              }
+            case ')':
+              {
+                if (!paramEscaped) paramOpenBrackets--;
+                paramEscaped = false;
+                break;
+              }
+            case '/':
+              {
+                if (char === '/' && paramOpenBrackets === 0) {
+                  mode = 'search';
+                  debug('mode: search');
+                }
+                paramEscaped = false;
+                break;
+              }
+            default:
+              {
+                paramEscaped = false;
+              }
+          }
+          break;
+        }
+    }
+    pos++;
+  }
+  // const parts = path.split('/')
+  // console.log('parts', parts)
+  // for (const part of parts) {
+  //     if (part !== '') {
+  //         if (part.startsWith(':')) priorityString += '1'
+  //         else priorityString += '2'
+  //     }
+  // }
+  return Number(priorityString);
+}

package/dist/routing/getPathPriority.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getPathPriority.sxyt.d.ts.map

package/dist/routing/getPathPriority.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPathPriority.sxyt.d.ts","sourceRoot":"","sources":["../../src/routing/getPathPriority.sxyt.ts"],"names":[],"mappings":""}

package/dist/routing/getPathPriority.sxyt.js

@@ -0,0 +1,24 @@
+import { describe } from 'sxy-test-runner';
+import { getPathPriority } from "./getPathPriority.js";
+describe('routing/compareRequestToRegex()', ({
+  it
+}) => {
+  it(`/foo returns priority 2`, () => {
+    const pattern = '/foo';
+    const priority = getPathPriority(pattern);
+    //console.log('priority', priority)
+    priority.should.equal(2);
+  });
+  it(`/foo/:bar/foo returns priority 212`, () => {
+    const pattern = '/foo/:bar/foo';
+    const priority = getPathPriority(pattern);
+    //console.log('priority', priority)
+    priority.should.equal(212);
+  });
+  it(`/foo/:bar([^\\/])/foo returns priority 212`, () => {
+    const pattern = '/foo/:bar([^\\/])/foo';
+    const priority = getPathPriority(pattern);
+    //console.log('priority', priority)
+    priority.should.equal(212);
+  });
+});

package/dist/routing/matchPath.d.ts

@@ -0,0 +1,3 @@
+import type { Match } from './Match.type.js';
+export declare function matchPath(pattern: `/${string}`, request: string): Match | null;
+//# sourceMappingURL=matchPath.d.ts.map

package/dist/routing/matchPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchPath.d.ts","sourceRoot":"","sources":["../../src/routing/matchPath.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAK5C,wBAAgB,SAAS,CAAC,OAAO,EAAE,IAAI,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CA6D9E"}