pict-microapp 1.0.0

package/types/Pict-MicroApp.d.ts

@@ -0,0 +1,192 @@
+export = PictMicroApp;
+declare class PictMicroApp extends libPictProvider {
+    /**
+     * @param {Object} pFable - the fable instance
+     * @param {Object} [pOptions] - provider options, including the Manifest
+     * @param {String} [pServiceHash] - the service hash
+     */
+    constructor(pFable: any, pOptions?: any, pServiceHash?: string);
+    /** The normalized manifest — always fully populated, whatever the author wrote. */
+    manifest: any;
+    /** Route patterns the gate refused, in registration order. Read this when a screen is missing. */
+    blockedRoutes: any[];
+    /** Route patterns the gate admitted with an entity guard. */
+    guardedRoutes: any[];
+    /** Route patterns that survived untouched. */
+    allowedRoutes: any[];
+    /** The original addRoute, kept so releaseRouter() can put the host back the way it was. */
+    _originalAddRoute: any;
+    /** The original navigo `on`, for the same reason. */
+    _originalRouterOn: any;
+    /** The router provider the gate is currently installed on. */
+    _gatedRouter: any;
+    /** True while the provider-level gate is delegating into the navigo-level one. */
+    _delegating: boolean;
+    /**
+     * The host's pict-router provider, or null before it exists.
+     *
+     * @return {Object|null} the router provider
+     */
+    get pictRouter(): any | null;
+    /**
+     * The host's navigation provider, or null when the host has none.
+     *
+     * @return {Object|null} the navigation provider
+     */
+    get navigationProvider(): any | null;
+    /**
+     * Replace the manifest after construction. Only meaningful before the gate is installed.
+     *
+     * @param {Object} pManifest - a micro app manifest
+     * @return {Object} the normalized manifest
+     */
+    setManifest(pManifest: any): any;
+    /**
+     * What would the gate do with this route? Exposed so an app (or a test) can ask without
+     * registering anything.
+     *
+     * @param {String} pRoute - a route pattern
+     * @return {{Mode: String, Route: String, Reason: String}} the decision
+     */
+    routeDecision(pRoute: string): {
+        Mode: string;
+        Route: string;
+        Reason: string;
+    };
+    /**
+     * Install the route gate on the host's router.
+     *
+     * MUST be called after the router provider exists but BEFORE the host registers its routes. In
+     * a pict application that means after the provider that owns routing has been added (usually in
+     * onInitializeAsync) and before the login/data-load cycle that registers them.
+     *
+     * Wrapping the instance method rather than the prototype keeps the blast radius to this one
+     * router: a host that shares pict-router with an embedded module is unaffected.
+     *
+     * TWO funnels are wrapped, not one. Most code registers through the provider's `addRoute`, but
+     * some modules reach past it and call the underlying router's `on` directly — pict-section-
+     * recordset's list, dashboard, associate and bulk-delete views all do, which is every one of its
+     * highest-traffic screens. Gating only `addRoute` silently leaves those wide open, and because
+     * they still work you would never notice. The provider-level wrapper sets `_delegating` while it
+     * calls through, so a route that came in via `addRoute` is decided once, not twice.
+     *
+     * @param {Object} [pPictRouter] - the router provider; defaults to the configured one
+     * @return {Boolean} whether the gate was installed
+     */
+    gateRouter(pPictRouter?: any): boolean;
+    /**
+     * Record (and optionally log) a route the gate refused.
+     *
+     * @param {{Route: String, Reason: String}} pDecision - the decision that blocked it
+     */
+    _noteBlocked(pDecision: {
+        Route: string;
+        Reason: string;
+    }): void;
+    /**
+     * Put the host's router back the way it was. Primarily for tests.
+     *
+     * @return {Boolean} whether a gate was removed
+     */
+    releaseRouter(): boolean;
+    /**
+     * Wrap an entity-parameterized route's handler so an entity the micro app does not expose
+     * bounces to the fallback instead of rendering.
+     *
+     * Wildcard record-set routes ('/PSRS/:RecordSet/List') are registered once by the host and fan
+     * out over every entity it knows. They cannot be refused per-entity at registration time, so
+     * this is where the subsetting has to happen.
+     *
+     * @param {String} pRoute - the canonical route pattern
+     * @param {Function|String} pRenderable - the host's handler
+     * @return {Function|String} the guarded handler, or the renderable untouched when it is a template
+     */
+    _guardRenderable(pRoute: string, pRenderable: Function | string): Function | string;
+    /**
+     * Send the browser to a route. Uses the host router when it is available so hooks and history
+     * behave the same as any other navigation.
+     *
+     * @param {String} pRoute - the route to navigate to
+     * @return {Boolean} whether a navigation was attempted
+     */
+    navigate(pRoute: string): boolean;
+    /**
+     * Point a hash that matched no surviving route at the fallback, so a stale bookmark into a
+     * screen this micro app does not carry lands somewhere real instead of on a blank page.
+     *
+     * @param {Object} [pPictRouter] - the router provider; defaults to the configured one
+     * @return {Boolean} whether the handler was installed
+     */
+    installNotFound(pPictRouter?: any): boolean;
+    /**
+     * Swap the host's navigation graph for the micro app's, and PIN it.
+     *
+     * Pinning is not paranoia. A host application of any size rebuilds its own navigation after the
+     * fact — as configuration loads, as permissions resolve, as dynamically registered sections
+     * appear — and each rebuild calls `setNavigationGraph` with the host's graph, silently undoing
+     * the swap. The symptom is the worst kind: the micro app's menu is correct at first paint and
+     * then quietly becomes the host's, usually after login, where nobody is looking.
+     *
+     * So rather than racing the host for the last write, the setter itself is wrapped: later calls
+     * still re-normalize and re-render, they just always land on the micro app's sections.
+     *
+     * @param {Object} [pNavigationProvider] - the navigation provider; defaults to the configured one
+     * @return {Boolean} whether the graph was swapped
+     */
+    applyNavigationGraph(pNavigationProvider?: any): boolean;
+    /**
+     * Install the micro app's navigation visibility gate.
+     *
+     * A host that serves many audiences usually trims its own (large) graph hard — the Headlight
+     * platform app, for instance, shows platform super-users only the handful of cross-customer
+     * destinations. Applied to a micro app graph, which is already the slimmed surface, that trim
+     * empties the menu completely. So the default here keeps the host's real gates (session,
+     * module, capability) and drops only the audience short-circuit.
+     *
+     * @param {Function} pHostPermitted - (pItem) => Boolean, the host's own per-item capability test
+     * @param {Object} [pOptions] - { IsPrivileged: () => Boolean } to keep privileged sessions unfiltered
+     * @return {Boolean} whether the gate was installed
+     */
+    applyNavigationGate(pHostPermitted: Function, pOptions?: any): boolean;
+    /**
+     * Point the host's routing provider at the micro app's landing route.
+     *
+     * @param {Object} pHostRouterProvider - the provider that owns `defaultRoute` (often a wrapper
+     *        around pict-router rather than pict-router itself)
+     * @return {Boolean} whether the landing route was set
+     */
+    applyDefaultRoute(pHostRouterProvider: any): boolean;
+    /**
+     * Apply the manifest's branding to the document.
+     *
+     * @return {Boolean} whether a title was set
+     */
+    applyBranding(): boolean;
+    /**
+     * A one-line summary of what the gate did, for the console and for tests.
+     *
+     * @return {{Name: String, Allowed: Number, Guarded: Number, Blocked: Number}} the tally
+     */
+    get routeTally(): {
+        Name: string;
+        Allowed: number;
+        Guarded: number;
+        Blocked: number;
+    };
+}
+declare namespace PictMicroApp {
+    export { _DEFAULT_PROVIDER_CONFIGURATION as default_configuration, libManifest as Manifest, composeMicroApp };
+}
+import libPictProvider = require("pict-provider");
+declare namespace _DEFAULT_PROVIDER_CONFIGURATION {
+    let ProviderIdentifier: string;
+    let AutoInitialize: boolean;
+    let AutoInitializeOrdinal: number;
+    let Manifest: {};
+    let RouterProviderHash: string;
+    let NavigationProviderHash: string;
+    let LogBlockedRoutes: boolean;
+}
+import libManifest = require("./Pict-MicroApp-Manifest.js");
+declare const composeMicroApp: typeof import("./Pict-MicroApp-Compose.js");
+//# sourceMappingURL=Pict-MicroApp.d.ts.map

package/types/Pict-MicroApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pict-MicroApp.d.ts","sourceRoot":"","sources":["../source/Pict-MicroApp.js"],"names":[],"mappings":";AA8CA;IAEC;;;;OAIG;IACH,gEA0BC;IAlBA,mFAAmF;IACnF,cAAoE;IAEpE,kGAAkG;IAClG,qBAAuB;IACvB,6DAA6D;IAC7D,qBAAuB;IACvB,8CAA8C;IAC9C,qBAAuB;IAEvB,2FAA2F;IAC3F,uBAA6B;IAC7B,qDAAqD;IACrD,uBAA6B;IAC7B,8DAA8D;IAC9D,kBAAwB;IACxB,kFAAkF;IAClF,qBAAwB;IAGzB;;;;OAIG;IACH,kBAFY,MAAO,IAAI,CAMtB;IAED;;;;OAIG;IACH,0BAFY,MAAO,IAAI,CAMtB;IAED;;;;;OAKG;IACH,iCAIC;IAED;;;;;;OAMG;IACH,+BAFY;QAAC,IAAI,SAAS;QAAC,KAAK,SAAS;QAAC,MAAM,SAAQ;KAAC,CAKxD;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,uCA8EC;IAED;;;;OAIG;IACH,wBAFW;QAAC,KAAK,SAAS;QAAC,MAAM,SAAQ;KAAC,QASzC;IAED;;;;OAIG;IACH,yBAeC;IAED;;;;;;;;;;;OAWG;IACH,8CAHW,iBAAe,GACd,iBAAe,CAmB1B;IAED;;;;;;OAMG;IACH,kCAeC;IAED;;;;;;OAMG;IACH,4CAkBC;IAED;;;;;;;;;;;;;;OAcG;IACH,yDAuBC;IAED;;;;;;;;;;;;OAYG;IACH,uEA+BC;IAED;;;;;;OAMG;IACH,qDASC;IAED;;;;OAIG;IACH,yBASC;IAED;;;;OAIG;IACH,kBAFY;QAAC,IAAI,SAAS;QAAC,OAAO,SAAS;QAAC,OAAO,SAAS;QAAC,OAAO,SAAQ;KAAC,CAW5E;CACD"}