@kaspernj/api-maker 1.0.2139 → 1.0.2142

package/build/result.d.ts

@@ -8,12 +8,234 @@ export default class ApiMakerResult {
      */
     constructor(data: {
         collection: import("./collection.js").default<any>;
-        models: Array<import("./base-model.js").default>;
+        models: Array<{
+            changes: {};
+            newRecord: boolean;
+            relationshipsCache: {};
+            relationships: {};
+            abilities: Record<string, any>;
+            modelData: {};
+            assignAttributes(newAttributes: Record<string, any>): void;
+            attributes(): Record<string, any>;
+            can(givenAbilityName: string): boolean;
+            clone(): /*elided*/ any;
+            cacheKey(): number | string;
+            localCacheKey(): string;
+            fullCacheKey(): string;
+            create(attributes?: Record<string, any>, options?: object): Promise<{
+                model: /*elided*/ any;
+                response: object;
+            }>;
+            createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                model: /*elided*/ any;
+                response: any;
+            }>;
+            destroy(): Promise<{
+                model: /*elided*/ any;
+                response: object;
+            }>;
+            ensureAbilities(listOfAbilities: string[]): Promise<void>;
+            getAttributes(): Record<string, any>;
+            handleResponseError(response: object): never;
+            identifierKey(): number | string;
+            _identifierKey: string | number;
+            isAssociationLoaded(associationName: string): boolean;
+            isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+            isAssociationPresent(associationName: string): boolean;
+            ensureAssociationLoaded(associationName: string): Promise<any>;
+            ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+            isAttributeChanged(attributeName: string): boolean;
+            isChanged(): boolean;
+            isNewRecord(): boolean;
+            isPersisted(): boolean;
+            savedChangeToAttribute(attributeName: string): boolean;
+            setNewModel(model: /*elided*/ any): void;
+            setNewModelData(model: /*elided*/ any): void;
+            previousModelData: any;
+            _isDateChanged(oldValue: any, newValue: any): boolean | void;
+            _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+            _isStringChanged(oldValue: any, newValue: any): boolean | void;
+            modelClassData(): ModelClassDataType;
+            reload(): Promise<void>;
+            save(): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            saveRaw(rawData: any, options?: {}): Promise<{
+                model: /*elided*/ any;
+                response: object;
+            }>;
+            update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            _refreshModelFromResponse(response: object): void;
+            _refreshModelDataFromResponse(response: object): void;
+            updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                response: object;
+                model: /*elided*/ any;
+            }>;
+            isValid(): never;
+            isValidOnServer(): Promise<{
+                valid: boolean;
+                errors: Record<string, any>;
+            }>;
+            modelClass(): Record<string, any>;
+            preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+            markForDestruction(): void;
+            _markedForDestruction: boolean;
+            markedForDestruction(): boolean;
+            uniqueKey(): number;
+            uniqueKeyValue: number;
+            _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+            readAttribute(attributeName: string): any;
+            readAttributeUnderscore(attributeName: string): any;
+            isAttributeLoaded(attributeName: any): boolean;
+            _isPresent(value: any): boolean;
+            _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+            _readBelongsToReflection({ reflectionName }: {
+                modelClass: any;
+                reflectionName: string;
+            }): any | null;
+            _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+            _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+            _readHasOneReflection({ reflectionName }: {
+                modelClass: any;
+                reflectionName: string;
+            }): any | null;
+            _readModelDataFromArgs(args?: {
+                data?: {
+                    b?: Record<string, any>;
+                    a?: Record<string, any>;
+                    r?: any;
+                };
+                collection?: import("./collection.js").default<any>;
+            }): void;
+            collection: import("./collection.js").default<any>;
+            preloadedRelationships: any;
+            _readPreloadedRelationships(preloaded: {
+                getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+            }): void;
+            primaryKey(): number | string;
+        }>;
         response: object;
     });
     data: {
         collection: import("./collection.js").default<any>;
-        models: Array<import("./base-model.js").default>;
+        models: Array<{
+            changes: {};
+            newRecord: boolean;
+            relationshipsCache: {};
+            relationships: {};
+            abilities: Record<string, any>;
+            modelData: {};
+            assignAttributes(newAttributes: Record<string, any>): void;
+            attributes(): Record<string, any>;
+            can(givenAbilityName: string): boolean;
+            clone(): /*elided*/ any;
+            cacheKey(): number | string;
+            localCacheKey(): string;
+            fullCacheKey(): string;
+            create(attributes?: Record<string, any>, options?: object): Promise<{
+                model: /*elided*/ any;
+                response: object;
+            }>;
+            createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+                model: /*elided*/ any;
+                response: any;
+            }>;
+            destroy(): Promise<{
+                model: /*elided*/ any;
+                response: object;
+            }>;
+            ensureAbilities(listOfAbilities: string[]): Promise<void>;
+            getAttributes(): Record<string, any>;
+            handleResponseError(response: object): never;
+            identifierKey(): number | string;
+            _identifierKey: string | number;
+            isAssociationLoaded(associationName: string): boolean;
+            isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+            isAssociationPresent(associationName: string): boolean;
+            ensureAssociationLoaded(associationName: string): Promise<any>;
+            ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+            isAttributeChanged(attributeName: string): boolean;
+            isChanged(): boolean;
+            isNewRecord(): boolean;
+            isPersisted(): boolean;
+            savedChangeToAttribute(attributeName: string): boolean;
+            setNewModel(model: /*elided*/ any): void;
+            setNewModelData(model: /*elided*/ any): void;
+            previousModelData: any;
+            _isDateChanged(oldValue: any, newValue: any): boolean | void;
+            _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+            _isStringChanged(oldValue: any, newValue: any): boolean | void;
+            modelClassData(): ModelClassDataType;
+            reload(): Promise<void>;
+            save(): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            saveRaw(rawData: any, options?: {}): Promise<{
+                model: /*elided*/ any;
+                response: object;
+            }>;
+            update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+                model: /*elided*/ any;
+                response?: object;
+            }>;
+            _refreshModelFromResponse(response: object): void;
+            _refreshModelDataFromResponse(response: object): void;
+            updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+                simpleModelErrors?: boolean;
+            }): Promise<{
+                response: object;
+                model: /*elided*/ any;
+            }>;
+            isValid(): never;
+            isValidOnServer(): Promise<{
+                valid: boolean;
+                errors: Record<string, any>;
+            }>;
+            modelClass(): Record<string, any>;
+            preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+            markForDestruction(): void;
+            _markedForDestruction: boolean;
+            markedForDestruction(): boolean;
+            uniqueKey(): number;
+            uniqueKeyValue: number;
+            _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+            readAttribute(attributeName: string): any;
+            readAttributeUnderscore(attributeName: string): any;
+            isAttributeLoaded(attributeName: any): boolean;
+            _isPresent(value: any): boolean;
+            _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+            _readBelongsToReflection({ reflectionName }: {
+                modelClass: any;
+                reflectionName: string;
+            }): any | null;
+            _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+            _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+            _readHasOneReflection({ reflectionName }: {
+                modelClass: any;
+                reflectionName: string;
+            }): any | null;
+            _readModelDataFromArgs(args?: {
+                data?: {
+                    b?: Record<string, any>;
+                    a?: Record<string, any>;
+                    r?: any;
+                };
+                collection?: import("./collection.js").default<any>;
+            }): void;
+            collection: import("./collection.js").default<any>;
+            preloadedRelationships: any;
+            _readPreloadedRelationships(preloaded: {
+                getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+            }): void;
+            primaryKey(): number | string;
+        }>;
         response: object;
     };
     /** @returns {number} */
@@ -21,7 +243,118 @@ export default class ApiMakerResult {
     /** @returns {number} */
     currentPage(): number;
     /** @returns {Array<import("./base-model.js").default>} */
-    models(): Array<import("./base-model.js").default>;
+    models(): Array<{
+        changes: {};
+        newRecord: boolean;
+        relationshipsCache: {};
+        relationships: {};
+        abilities: Record<string, any>;
+        modelData: {};
+        assignAttributes(newAttributes: Record<string, any>): void;
+        attributes(): Record<string, any>;
+        can(givenAbilityName: string): boolean;
+        clone(): /*elided*/ any;
+        cacheKey(): number | string;
+        localCacheKey(): string;
+        fullCacheKey(): string;
+        create(attributes?: Record<string, any>, options?: object): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        createRaw(rawData: FormData | Record<string, any>, options?: object): Promise<{
+            model: /*elided*/ any;
+            response: any;
+        }>;
+        destroy(): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        ensureAbilities(listOfAbilities: string[]): Promise<void>;
+        getAttributes(): Record<string, any>;
+        handleResponseError(response: object): never;
+        identifierKey(): number | string;
+        _identifierKey: string | number;
+        isAssociationLoaded(associationName: string): boolean;
+        isAssociationLoadedUnderscore(associationNameUnderscore: string): boolean;
+        isAssociationPresent(associationName: string): boolean;
+        ensureAssociationLoaded(associationName: string): Promise<any>;
+        ensureAssociationLoadedUnderscore(associationNameUnderscore: string): Promise<any>;
+        isAttributeChanged(attributeName: string): boolean;
+        isChanged(): boolean;
+        isNewRecord(): boolean;
+        isPersisted(): boolean;
+        savedChangeToAttribute(attributeName: string): boolean;
+        setNewModel(model: /*elided*/ any): void;
+        setNewModelData(model: /*elided*/ any): void;
+        previousModelData: any;
+        _isDateChanged(oldValue: any, newValue: any): boolean | void;
+        _isIntegerChanged(oldValue: any, newValue: any): boolean | void;
+        _isStringChanged(oldValue: any, newValue: any): boolean | void;
+        modelClassData(): ModelClassDataType;
+        reload(): Promise<void>;
+        save(): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        saveRaw(rawData: any, options?: {}): Promise<{
+            model: /*elided*/ any;
+            response: object;
+        }>;
+        update(newAttributes?: Record<string, any>, options?: ParseValidationErrorsOptions): Promise<{
+            model: /*elided*/ any;
+            response?: object;
+        }>;
+        _refreshModelFromResponse(response: object): void;
+        _refreshModelDataFromResponse(response: object): void;
+        updateRaw(rawData: FormData | Record<string, any>, options?: ParseValidationErrorsOptions & {
+            simpleModelErrors?: boolean;
+        }): Promise<{
+            response: object;
+            model: /*elided*/ any;
+        }>;
+        isValid(): never;
+        isValidOnServer(): Promise<{
+            valid: boolean;
+            errors: Record<string, any>;
+        }>;
+        modelClass(): Record<string, any>;
+        preloadRelationship(relationshipName: string, model: /*elided*/ any | /*elided*/ any[] | null): void;
+        markForDestruction(): void;
+        _markedForDestruction: boolean;
+        markedForDestruction(): boolean;
+        uniqueKey(): number;
+        uniqueKeyValue: number;
+        _callMemberCommand(args: Record<string, any>, commandArgs: Record<string, any>): Promise<object>;
+        readAttribute(attributeName: string): any;
+        readAttributeUnderscore(attributeName: string): any;
+        isAttributeLoaded(attributeName: any): boolean;
+        _isPresent(value: any): boolean;
+        _loadBelongsToReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any | null>;
+        _readBelongsToReflection({ reflectionName }: {
+            modelClass: any;
+            reflectionName: string;
+        }): any | null;
+        _loadHasManyReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<Array<any>>;
+        _loadHasOneReflection(args: import("./collection.js").CollectionArgsType<any>, queryArgs?: import("./collection.js").QueryArgsType): Promise<any>;
+        _readHasOneReflection({ reflectionName }: {
+            modelClass: any;
+            reflectionName: string;
+        }): any | null;
+        _readModelDataFromArgs(args?: {
+            data?: {
+                b?: Record<string, any>;
+                a?: Record<string, any>;
+                r?: any;
+            };
+            collection?: import("./collection.js").default<any>;
+        }): void;
+        collection: import("./collection.js").default<any>;
+        preloadedRelationships: any;
+        _readPreloadedRelationships(preloaded: {
+            getModel: (relationshipType: string, relationshipId: number | string) => /*elided*/ any;
+        }): void;
+        primaryKey(): number | string;
+    }>;
     /** @returns {typeof import("./base-model.js").default} */
     modelClass(): typeof import("./base-model.js").default;
     /** @returns {number} */

package/build/result.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"/src/","sources":["result.js"],"names":[],"mappings":"AAAA,sBAAsB;AACtB;IACE;;;;;OAKG;IACH,kBAJG;QAAgD,UAAU,EAAlD,sCAAiC;QACc,MAAM,EAArD,KAAK,CAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAC3B,QAAQ,EAArB,MAAM;KAChB,EAGA;IADC;;gBAJS,KAAK,CAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC;kBACxC,MAAM;MAGC;IAGlB,wBAAwB;IACxB,SADc,MAAM,CAC4B;IAEhD,wBAAwB;IACxB,eADc,MAAM,CACwC;IAE5D,0DAA0D;IAC1D,UADc,KAAK,CAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC,CAClB;IAEpC,0DAA0D;IAC1D,cADc,cAAc,iBAAiB,EAAE,OAAO,CACG;IAEzD,wBAAwB;IACxB,WADc,MAAM,CACgC;IAEpD,wBAAwB;IACxB,cADc,MAAM,CACsC;IAE1D,wBAAwB;IACxB,cADc,MAAM,CACsC;CAC3D"}
+{"version":3,"file":"result.d.ts","sourceRoot":"/src/","sources":["result.js"],"names":[],"mappings":"AAAA,sBAAsB;AACtB;IACE;;;;;OAKG;IACH,kBAJG;QAAgD,UAAU,EAAlD,sCAAiC;QACc,MAAM,EAArD,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4BqxsB,CAAC;;;;;;;;wBAA2iB,CAAC;;;;;iCAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA5B37xB,CAAC;QAC3B,QAAQ,EAArB,MAAM;KAChB,EAGA;IADC;;gBAJS,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA4BqxsB,CAAC;;;;;;;;wBAA2iB,CAAC;;;;;iCAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA5B37xB,CAAC;kBACxC,MAAM;MAGC;IAGlB,wBAAwB;IACxB,SADc,MAAM,CAC4B;IAEhD,wBAAwB;IACxB,eADc,MAAM,CACwC;IAE5D,0DAA0D;IAC1D,UADc,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAekxsB,CAAC;;;;;;;;oBAA2iB,CAAC;;;;;6BAAypE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAfx7xB,CAAC,CAClB;IAEpC,0DAA0D;IAC1D,cADc,cAAc,iBAAiB,EAAE,OAAO,CACG;IAEzD,wBAAwB;IACxB,WADc,MAAM,CACgC;IAEpD,wBAAwB;IACxB,cADc,MAAM,CACsC;IAE1D,wBAAwB;IACxB,cADc,MAAM,CACsC;CAC3D"}

package/build/router/switch.d.ts

@@ -1,5 +1,5 @@
 export default Switch;
-export const CurrentSwitchContext: React.Context<any[]>;
+export const CurrentSwitchContext: React.Context<any>;
 declare const Switch: any;
 import React from "react";
 //# sourceMappingURL=switch.d.ts.map

package/build/router/switch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"switch.d.ts","sourceRoot":"/src/","sources":["router/switch.jsx"],"names":[],"mappings":";AAQA,wDAA8C;AAE9C,0BA+DG;kBAxEgC,OAAO"}
+{"version":3,"file":"switch.d.ts","sourceRoot":"/src/","sources":["router/switch.jsx"],"names":[],"mappings":";AAQA,sDAAmE;AAEnE,0BA+DG;kBAxEgC,OAAO"}

package/build/router/switch.js

@@ -6,7 +6,7 @@ import BaseComponent from "../base-component";
 import PropTypes from "prop-types";
 import memo from "set-state-compare/build/memo.js";
 import propTypesExact from "prop-types-exact";
-const CurrentSwitchContext = createContext([]);
+const CurrentSwitchContext = createContext(/** @type {any} */ ({}));
 const Switch = memo(shapeComponent(class Switch extends BaseComponent {
     static defaultProps = {
         name: "[no name]",
@@ -58,4 +58,4 @@ const Switch = memo(shapeComponent(class Switch extends BaseComponent {
 }));
 export { CurrentSwitchContext };
 export default Switch;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/routes-native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes-native.d.ts","sourceRoot":"/src/","sources":["routes-native.js"],"names":[],"mappings":"AAKA,+FAA+F;AAC/F,gJAAgJ;AAChJ,iHAAiH;AACjH,kIAAkI;AAElI;;GAEG;AACH;IACE,iDAAiD;IACjD,2BADY;QAAC,SAAS,EAAE,MAAM,MAAM,CAAA;KAAC,EAKpC;IAHC,iBAF4B,MAAM,CAER;IAC1B,wBAA0B;IAC1B,0BAA+B;IAGjC;;;;OAIG;IACH,uCAJW,MAAM,wBACN;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAC,YAAC,GACpB,IAAI,CAwDhB;IAED;;;OAGG;IACH,4BAHW,MAAM,GACJ,IAAI,CAiBhB;IAdC,UAAgB;IAgBlB;;;OAGG;IACH,0DAHW,kBAAkB,GAChB,MAAM,CAgElB;IAED;;;OAGG;IACH,0DAHW,aAAa,GACX,MAAM,CA8BlB;CACF;uBAvMa;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAG;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC;iCACpE;IAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAC;4BAC3G;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAC;2BACjF;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC"}
+{"version":3,"file":"routes-native.d.ts","sourceRoot":"/src/","sources":["routes-native.js"],"names":[],"mappings":"AAKA,+FAA+F;AAC/F,gJAAgJ;AAChJ,iHAAiH;AACjH,kIAAkI;AAElI;;GAEG;AACH;IACE,iDAAiD;IACjD,2BADY;QAAC,SAAS,EAAE,MAAM,MAAM,CAAA;KAAC,EAKpC;IAHC,iBAF4B,MAAM,CAER;IAC1B,wBAA0B;IAC1B,0BAA+B;IAGjC;;;;OAIG;IACH,uCAJW,MAAM,wBACN;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAC,YAAC,GACpB,IAAI,CAyDhB;IAED;;;OAGG;IACH,4BAHW,MAAM,GACJ,IAAI,CAiBhB;IAdC,UAAgB;IAgBlB;;;OAGG;IACH,0DAHW,kBAAkB,GAChB,MAAM,CAgElB;IAED;;;OAGG;IACH,0DAHW,aAAa,GACX,MAAM,CA8BlB;CACF;uBAxMa;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAG;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC;iCACpE;IAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;IAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAC;4BAC3G;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAC;2BACjF;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC"}

package/build/routes-native.js

@@ -28,10 +28,11 @@ export default class ApiMakerRoutesNative {
             const pathMethodName = `${inflection.camelize(name, true)}Path`;
             const urlMethodName = `${inflection.camelize(name, true)}Url`;
             if (routeDefinitionArgs && routeDefinitionArgs.localized) {
-                const localizedRoutes = /** @type {Record<string, PathPart[]>} */ {};
+                const localizedRoutes = /** @type {Record<string, PathPart[]>} */ ({});
                 for (const locale in this.routeTranslationParts) {
                     let variableCount = 0;
-                    const localizedPathParts = /** @type {PathPart[]} */ [
+                    /** @type {PathPart[]} */
+                    const localizedPathParts = [
                         { type: "pathPart", name: "" },
                         { type: "pathPart", name: locale }
                     ];
@@ -179,4 +180,4 @@ export default class ApiMakerRoutesNative {
         return fullUrl;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routes-native.js","sourceRoot":"/src/","sources":["routes-native.js"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,YAAY,CAAA;AACxC,OAAO,EAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAC,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,MAAM,IAAI,CAAA;AACnB,OAAO,SAAS,MAAM,iBAAiB,CAAA;AAEvC,+FAA+F;AAC/F,gJAAgJ;AAChJ,iHAAiH;AACjH,kIAAkI;AAElI;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC,iDAAiD;IACjD,YAAa,EAAC,SAAS,EAAC;QACtB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAA;QAC1B,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAA;IACjC,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAE,gBAAgB,EAAE,mBAAmB;QACzD,KAAK,MAAM,eAAe,IAAI,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,EAAE,CAAC;YAC/D,MAAM,EAAC,IAAI,EAAE,IAAI,EAAC,GAAG,IAAI,CAAC,eAAe,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;YAC1D,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YACpC,MAAM,cAAc,GAAG,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAA;YAC/D,MAAM,aAAa,GAAG,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAA;YAE7D,IAAI,mBAAmB,IAAI,mBAAmB,CAAC,SAAS,EAAE,CAAC;gBACzD,MAAM,eAAe,GAAG,yCAAyC,CAAC,EAAE,CAAA;gBAEpE,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;oBAChD,IAAI,aAAa,GAAG,CAAC,CAAA;oBAErB,MAAM,kBAAkB,GAAG,yBAAyB,CAAC;wBACnD,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,EAAC;wBAC5B,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAC;qBACjC,CAAA;oBAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;wBAC7C,MAAM,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;wBAChC,MAAM,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,CAAA;wBAEpD,qCAAqC;wBACrC,IAAI,aAAa,EAAE,CAAC;4BAClB,kBAAkB,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,EAAC,CAAC,CAAA;wBACrE,CAAC;6BAAM,IAAI,QAAQ,EAAE,CAAC;4BACpB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAC,CAAC,CAAA;4BAEjF,kBAAkB,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAC,CAAC,CAAA;wBACnD,CAAC;oBACH,CAAC;oBAED,eAAe,CAAC,MAAM,CAAC,GAAG,kBAAkB,CAAA;gBAC9C,CAAC;gBAED,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,eAAe,EAAC,CAAC,CAAA;gBAChF,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,IAAI,EAAC,CAAC,CAAA;YAC5F,CAAC;iBAAM,CAAC;gBACN,IAAI,aAAa,GAAG,CAAC,CAAA;gBAErB,MAAM,SAAS,GAAG,yBAAyB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;oBACxE,MAAM,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,CAAA;oBAEpD,IAAI,aAAa,EAAE,CAAC;wBAClB,OAAO,EAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,EAAC,CAAA;oBACnD,CAAC;yBAAM,CAAC;wBACN,OAAO,EAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAC,CAAA;oBAC3C,CAAC;gBACH,CAAC,CAAC,CAAA;gBAEF,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,SAAS,EAAC,CAAC,CAAA;gBAC1E,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,IAAI,EAAC,CAAC,CAAA;YACtF,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,qBAAqB,CAAE,IAAI;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;QAErC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,MAAM,iBAAiB,GAAG,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAA;YAExD,IAAI,iBAAiB,EAAE,CAAC;gBACtB,IAAI,CAAC,CAAC,MAAM,IAAI,IAAI,CAAC,qBAAqB,CAAC;oBAAE,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,GAAG,EAAE,CAAA;gBAEpF,KAAK,MAAM,GAAG,IAAI,iBAAiB,EAAE,CAAC;oBACpC,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAA;gBAClE,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,cAAc,CAAE,EAAC,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,GAAG,EAAC;QACrD,IAAI,OAAO,GAAG,2BAA2B,CAAC,EAAE,CAAA;QAE5C,mCAAmC;QACnC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAErC,IAAI,OAAO,IAAI,OAAO,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC1C,OAAO,GAAG,2BAA2B,CAAC,IAAI,CAAC,GAAG,EAAE,CAAA;QAClD,CAAC;aAAM,CAAC;YACN,OAAO,GAAG,EAAE,CAAA;QACd,CAAC;QAED,6DAA6D;QAC7D,MAAM,EAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,WAAW,EAAC,GAAG,OAAO,CAAA;QAE9D,IAAI,eAAe,EAAE,CAAC;YACpB,8GAA8G;YAC9G,MAAM,mBAAmB,GAAG,yBAAyB,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC,CAAA;YACvG,IAAI,eAAe,GAAG,mBAAmB;iBACtC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;gBAChB,IAAI,QAAQ,CAAC,IAAI,IAAI,UAAU,EAAE,CAAC;oBAChC,OAAO,QAAQ,CAAC,IAAI,CAAA;gBACtB,CAAC;qBAAM,IAAI,QAAQ,CAAC,IAAI,IAAI,UAAU,EAAE,CAAC;oBACvC,sFAAsF;oBACtF,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAA;gBAC3C,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAA;gBAC7C,CAAC;YACH,CAAC,CAAC;iBACD,IAAI,CAAC,GAAG,CAAC,CAAA;YAEZ,IAAI,WAAW,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvD,eAAe,IAAI,IAAI,EAAE,CAAC,SAAS,CAAC,WAAW,EAAE,EAAC,OAAO,EAAE,SAAS,EAAC,CAAC,EAAE,CAAA;YAC1E,CAAC;YAED,IAAI,GAAG;gBAAE,OAAO,IAAI,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAC,CAAC,CAAA;YAE5E,OAAO,eAAe,CAAA;QACxB,CAAC;aAAM,IAAI,SAAS,EAAE,CAAC;YACrB,8GAA8G;YAC9G,IAAI,eAAe,GAAG,SAAS;iBAC5B,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;gBAChB,IAAI,QAAQ,CAAC,IAAI,IAAI,UAAU,EAAE,CAAC;oBAChC,OAAO,QAAQ,CAAC,IAAI,CAAA;gBACtB,CAAC;qBAAM,IAAI,QAAQ,CAAC,IAAI,IAAI,UAAU,EAAE,CAAC;oBACvC,OAAO,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAA;gBAC5C,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAA;gBAC7C,CAAC;YACH,CAAC,CAAC;iBACD,IAAI,CAAC,GAAG,CAAC,CAAA;YAEZ,IAAI,WAAW,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvD,eAAe,IAAI,IAAI,EAAE,CAAC,SAAS,CAAC,WAAW,EAAE,EAAC,OAAO,EAAE,SAAS,EAAC,CAAC,EAAE,CAAA;YAC1E,CAAC;YAED,IAAI,GAAG;gBAAE,OAAO,IAAI,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAC,CAAC,CAAA;YAE5E,OAAO,eAAe,CAAA;QACxB,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAA;IACpC,CAAC;IAED;;;OAGG;IACH,cAAc,CAAE,EAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAC;QACrD,IAAI,OAAO,GAAG,EAAE,CAAA;QAEhB,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;QACtF,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;QAEtF,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;QAExD,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,IAAI,GAAG,QAAQ,KAAK,CAAA;QAC7B,CAAC;aAAM,IAAI,UAAU,CAAC,QAAQ,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;YAC/D,OAAO,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,QAAQ,IAAI,CAAA;QAChD,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,UAAU,CAAA;QACvB,CAAC;QAED,OAAO,IAAI,SAAS,CAAA;QAEpB,MAAM,oBAAoB,GAAG,QAAQ,IAAI,MAAM,IAAI,SAAS,IAAI,EAAE,CAAA;QAClE,MAAM,qBAAqB,GAAG,QAAQ,IAAI,OAAO,IAAI,IAAI,IAAI,GAAG,CAAA;QAEhE,IAAI,SAAS,IAAI,CAAC,oBAAoB,IAAI,qBAAqB,CAAC,EAAE,CAAC;YACjE,OAAO,IAAI,IAAI,SAAS,EAAE,CAAA;QAC5B,CAAC;QAED,OAAO,IAAI,eAAe,CAAA;QAE1B,OAAO,OAAO,CAAA;IAChB,CAAC;CACF","sourcesContent":["import * as inflection from \"inflection\"\nimport {dig, digg, digs} from \"diggerize\"\nimport qs from \"qs\"\nimport urlEncode from \"./url-encode.js\"\n\n/** @typedef {{type: \"pathPart\", name: string} | {type: \"variable\", count: number}} PathPart */\n/** @typedef {{args: Array<unknown>, localizedRoutes?: Record<string, PathPart[]>, pathParts?: PathPart[], url?: boolean}} TranslateRouteArgs */\n/** @typedef {{host?: string, port?: number|string, protocol?: string, translatedRoute: string}} HostRouteArgs */\n/** @typedef {{locale?: string, host?: string, port?: number|string, protocol?: string} & Record<string, unknown>} RouteOptions */\n\n/**\n * Builds paths and URLs from route definitions for native usage.\n */\nexport default class ApiMakerRoutesNative {\n  /** @param {{getLocale: () => string}} options */\n  constructor ({getLocale}) {\n    this.getLocale = getLocale\n    this.routeDefinitions = []\n    this.routeTranslationParts = {}\n  }\n\n  /**\n   * @param {object} routeDefinitions\n   * @param {{localized?: boolean}=} routeDefinitionArgs\n   * @returns {void}\n   */\n  loadRouteDefinitions (routeDefinitions, routeDefinitionArgs) {\n    for (const routeDefinition of digg(routeDefinitions, \"routes\")) {\n      const {name, path} = digs(routeDefinition, \"name\", \"path\")\n      const rawPathParts = path.split(\"/\")\n      const pathMethodName = `${inflection.camelize(name, true)}Path`\n      const urlMethodName = `${inflection.camelize(name, true)}Url`\n\n      if (routeDefinitionArgs && routeDefinitionArgs.localized) {\n        const localizedRoutes = /** @type {Record<string, PathPart[]>} */ {}\n\n        for (const locale in this.routeTranslationParts) {\n          let variableCount = 0\n\n          const localizedPathParts = /** @type {PathPart[]} */ [\n            {type: \"pathPart\", name: \"\"},\n            {type: \"pathPart\", name: locale}\n          ]\n\n          for (let i = 1; i < rawPathParts.length; i++) {\n            const pathPart = rawPathParts[i]\n            const variableMatch = pathPart.match(/^:([A-z_]+)$/)\n\n            // eslint-disable-next-line max-depth\n            if (variableMatch) {\n              localizedPathParts.push({type: \"variable\", count: variableCount++})\n            } else if (pathPart) {\n              const name = this.i18n.t(`routes.${pathPart}`, null, {default: pathPart, locale})\n\n              localizedPathParts.push({type: \"pathPart\", name})\n            }\n          }\n\n          localizedRoutes[locale] = localizedPathParts\n        }\n\n        this[pathMethodName] = (...args) => this.translateRoute({args, localizedRoutes})\n        this[urlMethodName] = (...args) => this.translateRoute({args, localizedRoutes, url: true})\n      } else {\n        let variableCount = 0\n\n        const pathParts = /** @type {PathPart[]} */ rawPathParts.map((pathPart) => {\n          const variableMatch = pathPart.match(/^:([A-z_]+)$/)\n\n          if (variableMatch) {\n            return {type: \"variable\", count: variableCount++}\n          } else {\n            return {type: \"pathPart\", name: pathPart}\n          }\n        })\n\n        this[pathMethodName] = (...args) => this.translateRoute({args, pathParts})\n        this[urlMethodName] = (...args) => this.translateRoute({args, pathParts, url: true})\n      }\n    }\n  }\n\n  /**\n   * @param {object} i18n\n   * @returns {void}\n   */\n  loadRouteTranslations (i18n) {\n    this.i18n = i18n\n    const locales = digg(i18n, \"locales\")\n\n    for (const locale in locales) {\n      const routeTranslations = dig(locales, locale, \"routes\")\n\n      if (routeTranslations) {\n        if (!(locale in this.routeTranslationParts)) this.routeTranslationParts[locale] = {}\n\n        for (const key in routeTranslations) {\n          this.routeTranslationParts[locale][key] = routeTranslations[key]\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {TranslateRouteArgs} options\n   * @returns {string}\n   */\n  translateRoute ({args, localizedRoutes, pathParts, url}) {\n    let options = /** @type {RouteOptions} */ {}\n\n    // Extract options from args if any\n    const lastArg = args[args.length - 1]\n\n    if (lastArg && typeof lastArg == \"object\") {\n      options = /** @type {RouteOptions} */ args.pop()\n    } else {\n      options = {}\n    }\n\n    // Take locale from options if given or fall back to fallback\n    const {locale, host, port, protocol, ...restOptions} = options\n\n    if (localizedRoutes) {\n      // Put together route with variables and static translated parts (which were translated and cached previously)\n      const translatedPathParts = /** @type {PathPart[]} */ digg(localizedRoutes, locale || this.getLocale())\n      let translatedRoute = translatedPathParts\n        .map((pathPart) => {\n          if (pathPart.type == \"pathPart\") {\n            return pathPart.name\n          } else if (pathPart.type == \"variable\") {\n            // Args might not contain the right amount of variables, so dont change this to 'digg'\n            return dig(args, digg(pathPart, \"count\"))\n          } else {\n            throw new Error(\"Unhandled path part type\")\n          }\n        })\n        .join(\"/\")\n\n      if (restOptions && Object.keys(restOptions).length > 0) {\n        translatedRoute += `?${qs.stringify(restOptions, {encoder: urlEncode})}`\n      }\n\n      if (url) return this.addHostToRoute({host, port, protocol, translatedRoute})\n\n      return translatedRoute\n    } else if (pathParts) {\n      // Put together route with variables and static translated parts (which were translated and cached previously)\n      let translatedRoute = pathParts\n        .map((pathPart) => {\n          if (pathPart.type == \"pathPart\") {\n            return pathPart.name\n          } else if (pathPart.type == \"variable\") {\n            return digg(args, digg(pathPart, \"count\"))\n          } else {\n            throw new Error(\"Unhandled path part type\")\n          }\n        })\n        .join(\"/\")\n\n      if (restOptions && Object.keys(restOptions).length > 0) {\n        translatedRoute += `?${qs.stringify(restOptions, {encoder: urlEncode})}`\n      }\n\n      if (url) return this.addHostToRoute({host, port, protocol, translatedRoute})\n\n      return translatedRoute\n    }\n\n    throw new Error(\"Unhandled state\")\n  }\n\n  /**\n   * @param {HostRouteArgs} options\n   * @returns {string}\n   */\n  addHostToRoute ({host, port, protocol, translatedRoute}) {\n    let fullUrl = \"\"\n\n    const hostToUse = host || (globalThis.location ? globalThis.location.host : undefined)\n    const portToUse = port || (globalThis.location ? globalThis.location.port : undefined)\n\n    if (!hostToUse) throw new Error(\"Unable to detect host\")\n\n    if (protocol) {\n      fullUrl += `${protocol}://`\n    } else if (globalThis.location && globalThis.location.protocol) {\n      fullUrl += `${globalThis.location.protocol}//`\n    } else {\n      fullUrl += \"https://\"\n    }\n\n    fullUrl += hostToUse\n\n    const isHttpNonDefaultPort = protocol == \"http\" && portToUse != 80\n    const isHttpsNonDefaultPort = protocol == \"https\" && port != 443\n\n    if (portToUse && (isHttpNonDefaultPort || isHttpsNonDefaultPort)) {\n      fullUrl += `:${portToUse}`\n    }\n\n    fullUrl += translatedRoute\n\n    return fullUrl\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routes-native.js","sourceRoot":"/src/","sources":["routes-native.js"],"names":[],"mappings":"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","sourcesContent":["import * as inflection from \"inflection\"\nimport {dig, digg, digs} from \"diggerize\"\nimport qs from \"qs\"\nimport urlEncode from \"./url-encode.js\"\n\n/** @typedef {{type: \"pathPart\", name: string} | {type: \"variable\", count: number}} PathPart */\n/** @typedef {{args: Array<unknown>, localizedRoutes?: Record<string, PathPart[]>, pathParts?: PathPart[], url?: boolean}} TranslateRouteArgs */\n/** @typedef {{host?: string, port?: number|string, protocol?: string, translatedRoute: string}} HostRouteArgs */\n/** @typedef {{locale?: string, host?: string, port?: number|string, protocol?: string} & Record<string, unknown>} RouteOptions */\n\n/**\n * Builds paths and URLs from route definitions for native usage.\n */\nexport default class ApiMakerRoutesNative {\n  /** @param {{getLocale: () => string}} options */\n  constructor ({getLocale}) {\n    this.getLocale = getLocale\n    this.routeDefinitions = []\n    this.routeTranslationParts = {}\n  }\n\n  /**\n   * @param {object} routeDefinitions\n   * @param {{localized?: boolean}=} routeDefinitionArgs\n   * @returns {void}\n   */\n  loadRouteDefinitions (routeDefinitions, routeDefinitionArgs) {\n    for (const routeDefinition of digg(routeDefinitions, \"routes\")) {\n      const {name, path} = digs(routeDefinition, \"name\", \"path\")\n      const rawPathParts = path.split(\"/\")\n      const pathMethodName = `${inflection.camelize(name, true)}Path`\n      const urlMethodName = `${inflection.camelize(name, true)}Url`\n\n      if (routeDefinitionArgs && routeDefinitionArgs.localized) {\n        const localizedRoutes = /** @type {Record<string, PathPart[]>} */ ({})\n\n        for (const locale in this.routeTranslationParts) {\n          let variableCount = 0\n\n          /** @type {PathPart[]} */\n          const localizedPathParts = [\n            {type: \"pathPart\", name: \"\"},\n            {type: \"pathPart\", name: locale}\n          ]\n\n          for (let i = 1; i < rawPathParts.length; i++) {\n            const pathPart = rawPathParts[i]\n            const variableMatch = pathPart.match(/^:([A-z_]+)$/)\n\n            // eslint-disable-next-line max-depth\n            if (variableMatch) {\n              localizedPathParts.push({type: \"variable\", count: variableCount++})\n            } else if (pathPart) {\n              const name = this.i18n.t(`routes.${pathPart}`, null, {default: pathPart, locale})\n\n              localizedPathParts.push({type: \"pathPart\", name})\n            }\n          }\n\n          localizedRoutes[locale] = localizedPathParts\n        }\n\n        this[pathMethodName] = (...args) => this.translateRoute({args, localizedRoutes})\n        this[urlMethodName] = (...args) => this.translateRoute({args, localizedRoutes, url: true})\n      } else {\n        let variableCount = 0\n\n        const pathParts = /** @type {PathPart[]} */ rawPathParts.map((pathPart) => {\n          const variableMatch = pathPart.match(/^:([A-z_]+)$/)\n\n          if (variableMatch) {\n            return {type: \"variable\", count: variableCount++}\n          } else {\n            return {type: \"pathPart\", name: pathPart}\n          }\n        })\n\n        this[pathMethodName] = (...args) => this.translateRoute({args, pathParts})\n        this[urlMethodName] = (...args) => this.translateRoute({args, pathParts, url: true})\n      }\n    }\n  }\n\n  /**\n   * @param {object} i18n\n   * @returns {void}\n   */\n  loadRouteTranslations (i18n) {\n    this.i18n = i18n\n    const locales = digg(i18n, \"locales\")\n\n    for (const locale in locales) {\n      const routeTranslations = dig(locales, locale, \"routes\")\n\n      if (routeTranslations) {\n        if (!(locale in this.routeTranslationParts)) this.routeTranslationParts[locale] = {}\n\n        for (const key in routeTranslations) {\n          this.routeTranslationParts[locale][key] = routeTranslations[key]\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {TranslateRouteArgs} options\n   * @returns {string}\n   */\n  translateRoute ({args, localizedRoutes, pathParts, url}) {\n    let options = /** @type {RouteOptions} */ {}\n\n    // Extract options from args if any\n    const lastArg = args[args.length - 1]\n\n    if (lastArg && typeof lastArg == \"object\") {\n      options = /** @type {RouteOptions} */ args.pop()\n    } else {\n      options = {}\n    }\n\n    // Take locale from options if given or fall back to fallback\n    const {locale, host, port, protocol, ...restOptions} = options\n\n    if (localizedRoutes) {\n      // Put together route with variables and static translated parts (which were translated and cached previously)\n      const translatedPathParts = /** @type {PathPart[]} */ digg(localizedRoutes, locale || this.getLocale())\n      let translatedRoute = translatedPathParts\n        .map((pathPart) => {\n          if (pathPart.type == \"pathPart\") {\n            return pathPart.name\n          } else if (pathPart.type == \"variable\") {\n            // Args might not contain the right amount of variables, so dont change this to 'digg'\n            return dig(args, digg(pathPart, \"count\"))\n          } else {\n            throw new Error(\"Unhandled path part type\")\n          }\n        })\n        .join(\"/\")\n\n      if (restOptions && Object.keys(restOptions).length > 0) {\n        translatedRoute += `?${qs.stringify(restOptions, {encoder: urlEncode})}`\n      }\n\n      if (url) return this.addHostToRoute({host, port, protocol, translatedRoute})\n\n      return translatedRoute\n    } else if (pathParts) {\n      // Put together route with variables and static translated parts (which were translated and cached previously)\n      let translatedRoute = pathParts\n        .map((pathPart) => {\n          if (pathPart.type == \"pathPart\") {\n            return pathPart.name\n          } else if (pathPart.type == \"variable\") {\n            return digg(args, digg(pathPart, \"count\"))\n          } else {\n            throw new Error(\"Unhandled path part type\")\n          }\n        })\n        .join(\"/\")\n\n      if (restOptions && Object.keys(restOptions).length > 0) {\n        translatedRoute += `?${qs.stringify(restOptions, {encoder: urlEncode})}`\n      }\n\n      if (url) return this.addHostToRoute({host, port, protocol, translatedRoute})\n\n      return translatedRoute\n    }\n\n    throw new Error(\"Unhandled state\")\n  }\n\n  /**\n   * @param {HostRouteArgs} options\n   * @returns {string}\n   */\n  addHostToRoute ({host, port, protocol, translatedRoute}) {\n    let fullUrl = \"\"\n\n    const hostToUse = host || (globalThis.location ? globalThis.location.host : undefined)\n    const portToUse = port || (globalThis.location ? globalThis.location.port : undefined)\n\n    if (!hostToUse) throw new Error(\"Unable to detect host\")\n\n    if (protocol) {\n      fullUrl += `${protocol}://`\n    } else if (globalThis.location && globalThis.location.protocol) {\n      fullUrl += `${globalThis.location.protocol}//`\n    } else {\n      fullUrl += \"https://\"\n    }\n\n    fullUrl += hostToUse\n\n    const isHttpNonDefaultPort = protocol == \"http\" && portToUse != 80\n    const isHttpsNonDefaultPort = protocol == \"https\" && port != 443\n\n    if (portToUse && (isHttpNonDefaultPort || isHttpsNonDefaultPort)) {\n      fullUrl += `:${portToUse}`\n    }\n\n    fullUrl += translatedRoute\n\n    return fullUrl\n  }\n}\n"]}

package/build/services.d.ts

@@ -4,10 +4,10 @@ export default class ApiMakerServices {
     static current(): ApiMakerServices;
     /**
      * @param {string} serviceName
-     * @param {Record<string, any>} args
+     * @param {Record<string, any>} [args]
      * @param {Record<string, any>} [options]
      * @returns {Promise<any>}
      */
-    sendRequest(serviceName: string, args: Record<string, any>, options?: Record<string, any>): Promise<any>;
+    sendRequest(serviceName: string, args?: Record<string, any>, options?: Record<string, any>): Promise<any>;
 }
 //# sourceMappingURL=services.d.ts.map

package/build/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"/src/","sources":["services.js"],"names":[],"mappings":"AAIA,iCAAiC;AACjC;IACE,kCAAkC;IAClC,kBADc,gBAAgB,CAK7B;IAED;;;;;OAKG;IACH,yBALW,MAAM,QACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YACnB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,GAAG,CAAC,CAYxB;CACF"}
+{"version":3,"file":"services.d.ts","sourceRoot":"/src/","sources":["services.js"],"names":[],"mappings":"AAIA,iCAAiC;AACjC;IACE,kCAAkC;IAClC,kBADc,gBAAgB,CAK7B;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YACnB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAAC,GAAG,CAAC,CAYxB;CACF"}

package/build/services.js

@@ -10,7 +10,7 @@ export default class ApiMakerServices {
     }
     /**
      * @param {string} serviceName
-     * @param {Record<string, any>} args
+     * @param {Record<string, any>} [args]
      * @param {Record<string, any>} [options]
      * @returns {Promise<any>}
      */
@@ -26,4 +26,4 @@ export default class ApiMakerServices {
         }, options);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZXMuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbInNlcnZpY2VzLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sWUFBWSxNQUFNLG9CQUFvQixDQUFBO0FBRTdDLE1BQU0sTUFBTSxHQUFHLEVBQUUsQ0FBQTtBQUVqQixpQ0FBaUM7QUFDakMsTUFBTSxDQUFDLE9BQU8sT0FBTyxnQkFBZ0I7SUFDbkMsa0NBQWtDO0lBQ2xDLE1BQU0sQ0FBQyxPQUFPO1FBQ1osSUFBSSxDQUFDLE1BQU0sQ0FBQyxzQkFBc0I7WUFBRSxNQUFNLENBQUMsc0JBQXNCLEdBQUcsSUFBSSxnQkFBZ0IsRUFBRSxDQUFBO1FBRTFGLE9BQU8sTUFBTSxDQUFDLHNCQUFzQixDQUFBO0lBQ3RDLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILFdBQVcsQ0FBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLE9BQU8sR0FBRyxFQUFFO1FBQzFDLE9BQU8sWUFBWSxDQUFDLFVBQVUsQ0FBQztZQUM3QixJQUFJLEVBQUU7Z0JBQ0osWUFBWSxFQUFFLElBQUk7Z0JBQ2xCLFlBQVksRUFBRSxXQUFXO2FBQzFCO1lBQ0QsT0FBTyxFQUFFLFVBQVU7WUFDbkIsY0FBYyxFQUFFLE9BQU87WUFDdkIsSUFBSSxFQUFFLFNBQVM7U0FDaEIsRUFBRSxPQUFPLENBQUMsQ0FBQTtJQUNiLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBDb21tYW5kc1Bvb2wgZnJvbSBcIi4vY29tbWFuZHMtcG9vbC5qc1wiXG5cbmNvbnN0IHNoYXJlZCA9IHt9XG5cbi8qKiBBUEkgc2VydmljZSBjb21tYW5kIHByb3h5LiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXBpTWFrZXJTZXJ2aWNlcyB7XG4gIC8qKiBAcmV0dXJucyB7QXBpTWFrZXJTZXJ2aWNlc30gKi9cbiAgc3RhdGljIGN1cnJlbnQgKCkge1xuICAgIGlmICghc2hhcmVkLmN1cnJlbnRBcGlNYWtlclNlcnZpY2UpIHNoYXJlZC5jdXJyZW50QXBpTWFrZXJTZXJ2aWNlID0gbmV3IEFwaU1ha2VyU2VydmljZXMoKVxuXG4gICAgcmV0dXJuIHNoYXJlZC5jdXJyZW50QXBpTWFrZXJTZXJ2aWNlXG4gIH1cblxuICAvKipcbiAgICogQHBhcmFtIHtzdHJpbmd9IHNlcnZpY2VOYW1lXG4gICAqIEBwYXJhbSB7UmVjb3JkPHN0cmluZywgYW55Pn0gYXJnc1xuICAgKiBAcGFyYW0ge1JlY29yZDxzdHJpbmcsIGFueT59IFtvcHRpb25zXVxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTxhbnk+fVxuICAgKi9cbiAgc2VuZFJlcXVlc3QgKHNlcnZpY2VOYW1lLCBhcmdzLCBvcHRpb25zID0ge30pIHtcbiAgICByZXR1cm4gQ29tbWFuZHNQb29sLmFkZENvbW1hbmQoe1xuICAgICAgYXJnczoge1xuICAgICAgICBzZXJ2aWNlX2FyZ3M6IGFyZ3MsXG4gICAgICAgIHNlcnZpY2VfbmFtZTogc2VydmljZU5hbWVcbiAgICAgIH0sXG4gICAgICBjb21tYW5kOiBcInNlcnZpY2VzXCIsXG4gICAgICBjb2xsZWN0aW9uTmFtZTogXCJjYWxsc1wiLFxuICAgICAgdHlwZTogXCJzZXJ2aWNlXCJcbiAgICB9LCBvcHRpb25zKVxuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZXMuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbInNlcnZpY2VzLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sWUFBWSxNQUFNLG9CQUFvQixDQUFBO0FBRTdDLE1BQU0sTUFBTSxHQUFHLEVBQUUsQ0FBQTtBQUVqQixpQ0FBaUM7QUFDakMsTUFBTSxDQUFDLE9BQU8sT0FBTyxnQkFBZ0I7SUFDbkMsa0NBQWtDO0lBQ2xDLE1BQU0sQ0FBQyxPQUFPO1FBQ1osSUFBSSxDQUFDLE1BQU0sQ0FBQyxzQkFBc0I7WUFBRSxNQUFNLENBQUMsc0JBQXNCLEdBQUcsSUFBSSxnQkFBZ0IsRUFBRSxDQUFBO1FBRTFGLE9BQU8sTUFBTSxDQUFDLHNCQUFzQixDQUFBO0lBQ3RDLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILFdBQVcsQ0FBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLE9BQU8sR0FBRyxFQUFFO1FBQzFDLE9BQU8sWUFBWSxDQUFDLFVBQVUsQ0FBQztZQUM3QixJQUFJLEVBQUU7Z0JBQ0osWUFBWSxFQUFFLElBQUk7Z0JBQ2xCLFlBQVksRUFBRSxXQUFXO2FBQzFCO1lBQ0QsT0FBTyxFQUFFLFVBQVU7WUFDbkIsY0FBYyxFQUFFLE9BQU87WUFDdkIsSUFBSSxFQUFFLFNBQVM7U0FDaEIsRUFBRSxPQUFPLENBQUMsQ0FBQTtJQUNiLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBDb21tYW5kc1Bvb2wgZnJvbSBcIi4vY29tbWFuZHMtcG9vbC5qc1wiXG5cbmNvbnN0IHNoYXJlZCA9IHt9XG5cbi8qKiBBUEkgc2VydmljZSBjb21tYW5kIHByb3h5LiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQXBpTWFrZXJTZXJ2aWNlcyB7XG4gIC8qKiBAcmV0dXJucyB7QXBpTWFrZXJTZXJ2aWNlc30gKi9cbiAgc3RhdGljIGN1cnJlbnQgKCkge1xuICAgIGlmICghc2hhcmVkLmN1cnJlbnRBcGlNYWtlclNlcnZpY2UpIHNoYXJlZC5jdXJyZW50QXBpTWFrZXJTZXJ2aWNlID0gbmV3IEFwaU1ha2VyU2VydmljZXMoKVxuXG4gICAgcmV0dXJuIHNoYXJlZC5jdXJyZW50QXBpTWFrZXJTZXJ2aWNlXG4gIH1cblxuICAvKipcbiAgICogQHBhcmFtIHtzdHJpbmd9IHNlcnZpY2VOYW1lXG4gICAqIEBwYXJhbSB7UmVjb3JkPHN0cmluZywgYW55Pn0gW2FyZ3NdXG4gICAqIEBwYXJhbSB7UmVjb3JkPHN0cmluZywgYW55Pn0gW29wdGlvbnNdXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPGFueT59XG4gICAqL1xuICBzZW5kUmVxdWVzdCAoc2VydmljZU5hbWUsIGFyZ3MsIG9wdGlvbnMgPSB7fSkge1xuICAgIHJldHVybiBDb21tYW5kc1Bvb2wuYWRkQ29tbWFuZCh7XG4gICAgICBhcmdzOiB7XG4gICAgICAgIHNlcnZpY2VfYXJnczogYXJncyxcbiAgICAgICAgc2VydmljZV9uYW1lOiBzZXJ2aWNlTmFtZVxuICAgICAgfSxcbiAgICAgIGNvbW1hbmQ6IFwic2VydmljZXNcIixcbiAgICAgIGNvbGxlY3Rpb25OYW1lOiBcImNhbGxzXCIsXG4gICAgICB0eXBlOiBcInNlcnZpY2VcIlxuICAgIH0sIG9wdGlvbnMpXG4gIH1cbn1cbiJdfQ==

package/build/super-admin/config-reader.js

@@ -1,6 +1,6 @@
 import * as inflection from "inflection";
 import { digg, digs } from "diggerize";
-const modelConfigRequireContext = import.meta.webpackContext("super-admin/model-configs", {
+const modelConfigRequireContext = /** @type {any} */ (import.meta).webpackContext("super-admin/model-configs", {
     recursive: true,
     regExp: /\.(jsx|js)$/
 });
@@ -80,4 +80,4 @@ export default class ApiMakerSuperAdminConfigReader {
         return { columns, select };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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