@cratis/scene.primereact 4.6.0 → 4.8.0

package/dist/cjs/file/PrimeFileUpload.js

@@ -0,0 +1,161 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var fileupload = require('primereact/fileupload');
+var properties = require('../properties.js');
+var resolveEnumeration = require('../resolveEnumeration.js');
+var FileUploadContext = require('./FileUploadContext.js');
+var FileUploadMode = require('./FileUploadMode.js');
+var resolveUploadTarget = require('./resolveUploadTarget.js');
+var useUploadSession = require('./useUploadSession.js');
+
+const subscribeToNothing = ()=>()=>undefined;
+const pageOrigin = ()=>window.location.origin;
+const noPageOrigin = ()=>undefined;
+/**
+ * The `PrimeReact:fileUpload` component.
+ *
+ * PrimeReact 11 provides the accessible file picker and drop zone; this adapter owns everything that has an
+ * effect or a policy:
+ * - The authored `url` is untrusted data. It is checked by {@link resolveUploadTarget} - same origin as the
+ *   page unless the host allows more through {@link FileUploadHandlerProvider} - and a refused address is
+ *   reported and blocks every upload, the host's handler included.
+ * - Nothing is requested on mount. A request starts only when the user selects or drops files (automatic and
+ *   basic mode) or presses the upload button.
+ * - `multiple: false` is enforced before anything is sent, for the file input and for drag and drop.
+ * - One upload runs at a time (nothing can be selected or dropped while it runs), and a failure is shown
+ *   rather than thrown.
+ * - A disabled element (`isEnabled: false`) disables the picker, the upload button and the drop zone.
+ *
+ * Without a host handler the control posts the files itself with `fetch`, sending cookies to the page's own
+ * origin only.
+ */ function PrimeFileUpload({ element, interactions }) {
+    const { handler, allowedOrigins } = react.useContext(FileUploadContext.FileUploadContext);
+    const origin = react.useSyncExternalStore(subscribeToNothing, pageOrigin, noPageOrigin);
+    const modeResolution = resolveEnumeration.resolveEnumeration('mode', element.properties.mode, FileUploadMode.FileUploadMode, FileUploadMode.FileUploadMode.Advanced);
+    const mode = modeResolution.isValid ? modeResolution.value : FileUploadMode.FileUploadMode.Advanced;
+    const authoredUrl = properties.stringProperty(element, 'url');
+    const target = react.useMemo(()=>resolveUploadTarget.resolveUploadTarget(authoredUrl, origin, allowedOrigins), [
+        authoredUrl,
+        origin,
+        allowedOrigins
+    ]);
+    const serverUrl = target.isValid ? target.url : undefined;
+    const multiple = properties.booleanProperty(element, 'multiple', false);
+    const enabled = element.isEnabled;
+    const canUpload = target.isValid && (handler !== undefined || serverUrl !== undefined);
+    const session = useUploadSession.useUploadSession(handler, serverUrl, properties.stringProperty(element, 'name', 'files'));
+    const uploaded = async (event)=>{
+        if (!enabled || !canUpload) return;
+        if (await session.upload(event.files)) event.options.clear();
+    };
+    const changed = (event)=>{
+        // Clearing the selection after an upload reports an empty change; it is not a new selection, and must not
+        // wipe the result of the upload that caused it.
+        if (event.acceptedFiles.length === 0 && event.rejectedFiles.length === 0) return;
+        const rejection = event.rejectedFiles.flatMap((rejected)=>rejected.errors.map((error)=>error.message)).join(' ');
+        session.setStatus(rejection === '' ? undefined : {
+            kind: 'error',
+            text: rejection
+        });
+        interactions?.onChange?.();
+    };
+    const refuseSeveralFromInput = (event)=>{
+        const input = event.target;
+        if (input.type !== 'file') return;
+        if (session.busy) {
+            event.stopPropagation();
+            input.value = '';
+            return;
+        }
+        if (multiple || (input.files?.length ?? 0) < 2) return;
+        event.stopPropagation();
+        input.value = '';
+        session.setStatus({
+            kind: 'error',
+            text: 'Only one file can be uploaded at a time.'
+        });
+    };
+    const refuseDrop = (event)=>{
+        if (!enabled) {
+            event.preventDefault();
+            return;
+        }
+        if (session.busy) {
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+        }
+        if (multiple || (event.dataTransfer?.files.length ?? 0) < 2) return;
+        event.preventDefault();
+        event.stopPropagation();
+        session.setStatus({
+            kind: 'error',
+            text: 'Only one file can be uploaded at a time.'
+        });
+    };
+    return /*#__PURE__*/ jsxRuntime.jsx("div", {
+        "data-scene-id": element.id,
+        "data-scene-component": "fileUpload",
+        onClick: interactions?.onClick,
+        onDoubleClick: interactions?.onDoubleClick,
+        onChangeCapture: refuseSeveralFromInput,
+        onDropCapture: refuseDrop,
+        onDragOverCapture: (event)=>{
+            if (!enabled) event.preventDefault();
+        },
+        children: /*#__PURE__*/ jsxRuntime.jsx(fileupload.FileUpload.Root, {
+            accept: properties.stringProperty(element, 'accept'),
+            auto: (mode === FileUploadMode.FileUploadMode.Auto || mode === FileUploadMode.FileUploadMode.Basic) && canUpload,
+            customUpload: true,
+            disabled: !enabled,
+            maxFileSize: properties.numberProperty(element, 'maxFileSize'),
+            multiple: multiple,
+            name: properties.stringProperty(element, 'name', 'files'),
+            uploadHandler: uploaded,
+            onChange: changed,
+            children: /*#__PURE__*/ jsxRuntime.jsxs(fileupload.FileUpload.Content, {
+                "aria-label": properties.stringProperty(element, 'ariaLabel', 'File upload drop zone'),
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsx("p", {
+                        children: mode === FileUploadMode.FileUploadMode.Basic ? 'Choose a file to upload.' : 'Drop files here or choose files to upload.'
+                    }),
+                    /*#__PURE__*/ jsxRuntime.jsx(fileupload.FileUpload.Trigger, {
+                        disabled: !enabled || session.busy,
+                        children: mode === FileUploadMode.FileUploadMode.Basic ? 'Choose file' : 'Choose files'
+                    }),
+                    mode === FileUploadMode.FileUploadMode.Advanced && /*#__PURE__*/ jsxRuntime.jsx(fileupload.FileUpload.Upload, {
+                        disabled: !enabled || !canUpload || session.busy,
+                        children: "Upload selected files"
+                    }),
+                    !modeResolution.isValid && /*#__PURE__*/ jsxRuntime.jsx("p", {
+                        role: "alert",
+                        "data-scene-state": "unsupported-mode",
+                        children: modeResolution.message
+                    }),
+                    !target.isValid && /*#__PURE__*/ jsxRuntime.jsx("p", {
+                        role: "alert",
+                        "data-scene-state": "refused-address",
+                        children: target.message
+                    }),
+                    target.isValid && !canUpload && /*#__PURE__*/ jsxRuntime.jsx("p", {
+                        role: "status",
+                        children: "Configure a server URL or provide an upload handler to upload files."
+                    }),
+                    session.busy && /*#__PURE__*/ jsxRuntime.jsx("p", {
+                        role: "status",
+                        children: "Uploading…"
+                    }),
+                    session.status !== undefined && /*#__PURE__*/ jsxRuntime.jsx("p", {
+                        role: session.status.kind === 'error' ? 'alert' : 'status',
+                        children: session.status.text
+                    })
+                ]
+            })
+        })
+    });
+}
+
+exports.PrimeFileUpload = PrimeFileUpload;
+//# sourceMappingURL=PrimeFileUpload.js.map

package/dist/cjs/file/PrimeFileUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeFileUpload.js","sources":["../../../file/PrimeFileUpload.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { ChangeEvent, DragEvent, useContext, useMemo, useSyncExternalStore } from 'react';\nimport { FileUpload, type FileUploadChangeEvent, type FileUploadHandlerEvent } from 'primereact/fileupload';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, numberProperty, stringProperty } from '../properties';\nimport { resolveEnumeration } from '../resolveEnumeration';\nimport { FileUploadContext } from './FileUploadContext';\nimport { FileUploadMode } from './FileUploadMode';\nimport { resolveUploadTarget } from './resolveUploadTarget';\nimport { useUploadSession } from './useUploadSession';\n\nconst subscribeToNothing = () => () => undefined;\nconst pageOrigin = () => window.location.origin;\nconst noPageOrigin = () => undefined;\n\n/**\n * The `PrimeReact:fileUpload` component.\n *\n * PrimeReact 11 provides the accessible file picker and drop zone; this adapter owns everything that has an\n * effect or a policy:\n * - The authored `url` is untrusted data. It is checked by {@link resolveUploadTarget} - same origin as the\n *   page unless the host allows more through {@link FileUploadHandlerProvider} - and a refused address is\n *   reported and blocks every upload, the host's handler included.\n * - Nothing is requested on mount. A request starts only when the user selects or drops files (automatic and\n *   basic mode) or presses the upload button.\n * - `multiple: false` is enforced before anything is sent, for the file input and for drag and drop.\n * - One upload runs at a time (nothing can be selected or dropped while it runs), and a failure is shown\n *   rather than thrown.\n * - A disabled element (`isEnabled: false`) disables the picker, the upload button and the drop zone.\n *\n * Without a host handler the control posts the files itself with `fetch`, sending cookies to the page's own\n * origin only.\n */\nexport function PrimeFileUpload({ element, interactions }: RegisteredComponentProps) {\n    const { handler, allowedOrigins } = useContext(FileUploadContext);\n    const origin = useSyncExternalStore(subscribeToNothing, pageOrigin, noPageOrigin);\n    const modeResolution = resolveEnumeration('mode', element.properties.mode, FileUploadMode, FileUploadMode.Advanced);\n    const mode = modeResolution.isValid ? modeResolution.value : FileUploadMode.Advanced;\n    const authoredUrl = stringProperty(element, 'url');\n    const target = useMemo(() => resolveUploadTarget(authoredUrl, origin, allowedOrigins), [authoredUrl, origin, allowedOrigins]);\n    const serverUrl = target.isValid ? target.url : undefined;\n    const multiple = booleanProperty(element, 'multiple', false);\n    const enabled = element.isEnabled;\n    const canUpload = target.isValid && (handler !== undefined || serverUrl !== undefined);\n    const session = useUploadSession(handler, serverUrl, stringProperty(element, 'name', 'files'));\n\n    const uploaded = async (event: FileUploadHandlerEvent) => {\n        if (!enabled || !canUpload) return;\n        if (await session.upload(event.files)) event.options.clear();\n    };\n\n    const changed = (event: FileUploadChangeEvent) => {\n        // Clearing the selection after an upload reports an empty change; it is not a new selection, and must not\n        // wipe the result of the upload that caused it.\n        if (event.acceptedFiles.length === 0 && event.rejectedFiles.length === 0) return;\n        const rejection = event.rejectedFiles.flatMap(rejected => rejected.errors.map(error => error.message)).join(' ');\n        session.setStatus(rejection === '' ? undefined : { kind: 'error', text: rejection });\n        interactions?.onChange?.();\n    };\n\n    const refuseSeveralFromInput = (event: ChangeEvent<HTMLElement>) => {\n        const input = event.target as HTMLInputElement;\n        if (input.type !== 'file') return;\n        if (session.busy) {\n            event.stopPropagation();\n            input.value = '';\n            return;\n        }\n\n        if (multiple || (input.files?.length ?? 0) < 2) return;\n        event.stopPropagation();\n        input.value = '';\n        session.setStatus({ kind: 'error', text: 'Only one file can be uploaded at a time.' });\n    };\n\n    const refuseDrop = (event: DragEvent<HTMLElement>) => {\n        if (!enabled) {\n            event.preventDefault();\n            return;\n        }\n        if (session.busy) {\n            event.preventDefault();\n            event.stopPropagation();\n            return;\n        }\n\n        if (multiple || (event.dataTransfer?.files.length ?? 0) < 2) return;\n        event.preventDefault();\n        event.stopPropagation();\n        session.setStatus({ kind: 'error', text: 'Only one file can be uploaded at a time.' });\n    };\n\n    return (\n        <div\n            data-scene-id={element.id}\n            data-scene-component='fileUpload'\n            onClick={interactions?.onClick}\n            onDoubleClick={interactions?.onDoubleClick}\n            onChangeCapture={refuseSeveralFromInput}\n            onDropCapture={refuseDrop}\n            onDragOverCapture={event => { if (!enabled) event.preventDefault(); }}>\n            <FileUpload.Root\n                accept={stringProperty(element, 'accept')}\n                auto={(mode === FileUploadMode.Auto || mode === FileUploadMode.Basic) && canUpload}\n                customUpload\n                disabled={!enabled}\n                maxFileSize={numberProperty(element, 'maxFileSize')}\n                multiple={multiple}\n                name={stringProperty(element, 'name', 'files')}\n                uploadHandler={uploaded}\n                onChange={changed}>\n                <FileUpload.Content aria-label={stringProperty(element, 'ariaLabel', 'File upload drop zone')}>\n                    <p>{mode === FileUploadMode.Basic ? 'Choose a file to upload.' : 'Drop files here or choose files to upload.'}</p>\n                    <FileUpload.Trigger disabled={!enabled || session.busy}>{mode === FileUploadMode.Basic ? 'Choose file' : 'Choose files'}</FileUpload.Trigger>\n                    {mode === FileUploadMode.Advanced && (\n                        <FileUpload.Upload disabled={!enabled || !canUpload || session.busy}>Upload selected files</FileUpload.Upload>\n                    )}\n                    {!modeResolution.isValid && <p role='alert' data-scene-state='unsupported-mode'>{modeResolution.message}</p>}\n                    {!target.isValid && <p role='alert' data-scene-state='refused-address'>{target.message}</p>}\n                    {target.isValid && !canUpload && <p role='status'>Configure a server URL or provide an upload handler to upload files.</p>}\n                    {session.busy && <p role='status'>Uploading…</p>}\n                    {session.status !== undefined && <p role={session.status.kind === 'error' ? 'alert' : 'status'}>{session.status.text}</p>}\n                </FileUpload.Content>\n            </FileUpload.Root>\n        </div>\n    );\n}\n"],"names":["subscribeToNothing","undefined","pageOrigin","window","location","origin","noPageOrigin","PrimeFileUpload","element","interactions","handler","allowedOrigins","useContext","FileUploadContext","useSyncExternalStore","modeResolution","resolveEnumeration","properties","mode","FileUploadMode","Advanced","isValid","value","authoredUrl","stringProperty","target","useMemo","resolveUploadTarget","serverUrl","url","multiple","booleanProperty","enabled","isEnabled","canUpload","session","useUploadSession","uploaded","event","upload","files","options","clear","changed","acceptedFiles","length","rejectedFiles","rejection","flatMap","rejected","errors","map","error","message","join","setStatus","kind","text","onChange","refuseSeveralFromInput","input","type","busy","stopPropagation","refuseDrop","preventDefault","dataTransfer","_jsx","div","data-scene-id","id","data-scene-component","onClick","onDoubleClick","onChangeCapture","onDropCapture","onDragOverCapture","FileUpload","Root","accept","auto","Auto","Basic","customUpload","disabled","maxFileSize","numberProperty","name","uploadHandler","_jsxs","Content","aria-label","p","Trigger","Upload","role","data-scene-state","status"],"mappings":";;;;;;;;;;;;AAaA,MAAMA,kBAAAA,GAAqB,IAAM,IAAMC,SAAAA;AACvC,MAAMC,UAAAA,GAAa,IAAMC,MAAAA,CAAOC,QAAQ,CAACC,MAAM;AAC/C,MAAMC,eAAe,IAAML,SAAAA;AAE3B;;;;;;;;;;;;;;;;;AAiBC,IACM,SAASM,eAAAA,CAAgB,EAAEC,OAAO,EAAEC,YAAY,EAA4B,EAAA;AAC/E,IAAA,MAAM,EAAEC,OAAO,EAAEC,cAAc,EAAE,GAAGC,gBAAAA,CAAWC,mCAAAA,CAAAA;IAC/C,MAAMR,MAAAA,GAASS,0BAAAA,CAAqBd,kBAAAA,EAAoBE,UAAAA,EAAYI,YAAAA,CAAAA;IACpE,MAAMS,cAAAA,GAAiBC,qCAAAA,CAAmB,MAAA,EAAQR,OAAAA,CAAQS,UAAU,CAACC,IAAI,EAAEC,6BAAAA,EAAgBA,6BAAAA,CAAeC,QAAQ,CAAA;IAClH,MAAMF,IAAAA,GAAOH,eAAeM,OAAO,GAAGN,eAAeO,KAAK,GAAGH,8BAAeC,QAAQ;IACpF,MAAMG,WAAAA,GAAcC,0BAAehB,OAAAA,EAAS,KAAA,CAAA;AAC5C,IAAA,MAAMiB,SAASC,aAAAA,CAAQ,IAAMC,uCAAAA,CAAoBJ,WAAAA,EAAalB,QAAQM,cAAAA,CAAAA,EAAiB;AAACY,QAAAA,WAAAA;AAAalB,QAAAA,MAAAA;AAAQM,QAAAA;AAAe,KAAA,CAAA;AAC5H,IAAA,MAAMiB,YAAYH,MAAAA,CAAOJ,OAAO,GAAGI,MAAAA,CAAOI,GAAG,GAAG5B,SAAAA;IAChD,MAAM6B,QAAAA,GAAWC,0BAAAA,CAAgBvB,OAAAA,EAAS,UAAA,EAAY,KAAA,CAAA;IACtD,MAAMwB,OAAAA,GAAUxB,QAAQyB,SAAS;IACjC,MAAMC,SAAAA,GAAYT,OAAOJ,OAAO,KAAKX,OAAAA,KAAYT,SAAAA,IAAa2B,cAAc3B,SAAQ,CAAA;AACpF,IAAA,MAAMkC,UAAUC,iCAAAA,CAAiB1B,OAAAA,EAASkB,SAAAA,EAAWJ,yBAAAA,CAAehB,SAAS,MAAA,EAAQ,OAAA,CAAA,CAAA;AAErF,IAAA,MAAM6B,WAAW,OAAOC,KAAAA,GAAAA;QACpB,IAAI,CAACN,OAAAA,IAAW,CAACE,SAAAA,EAAW;QAC5B,IAAI,MAAMC,OAAAA,CAAQI,MAAM,CAACD,KAAAA,CAAME,KAAK,CAAA,EAAGF,KAAAA,CAAMG,OAAO,CAACC,KAAK,EAAA;AAC9D,IAAA,CAAA;AAEA,IAAA,MAAMC,UAAU,CAACL,KAAAA,GAAAA;;;QAGb,IAAIA,KAAAA,CAAMM,aAAa,CAACC,MAAM,KAAK,CAAA,IAAKP,KAAAA,CAAMQ,aAAa,CAACD,MAAM,KAAK,CAAA,EAAG;AAC1E,QAAA,MAAME,YAAYT,KAAAA,CAAMQ,aAAa,CAACE,OAAO,CAACC,CAAAA,QAAAA,GAAYA,QAAAA,CAASC,MAAM,CAACC,GAAG,CAACC,CAAAA,KAAAA,GAASA,MAAMC,OAAO,CAAA,CAAA,CAAGC,IAAI,CAAC,GAAA,CAAA;AAC5GnB,QAAAA,OAAAA,CAAQoB,SAAS,CAACR,SAAAA,KAAc,EAAA,GAAK9C,SAAAA,GAAY;YAAEuD,IAAAA,EAAM,OAAA;YAASC,IAAAA,EAAMV;AAAU,SAAA,CAAA;QAClFtC,YAAAA,EAAciD,QAAAA,IAAAA;AAClB,IAAA,CAAA;AAEA,IAAA,MAAMC,yBAAyB,CAACrB,KAAAA,GAAAA;QAC5B,MAAMsB,KAAAA,GAAQtB,MAAMb,MAAM;QAC1B,IAAImC,KAAAA,CAAMC,IAAI,KAAK,MAAA,EAAQ;QAC3B,IAAI1B,OAAAA,CAAQ2B,IAAI,EAAE;AACdxB,YAAAA,KAAAA,CAAMyB,eAAe,EAAA;AACrBH,YAAAA,KAAAA,CAAMtC,KAAK,GAAG,EAAA;AACd,YAAA;AACJ,QAAA;QAEA,IAAIQ,QAAAA,IAAY,CAAC8B,KAAAA,CAAMpB,KAAK,EAAEK,MAAAA,IAAU,CAAA,IAAK,CAAA,EAAG;AAChDP,QAAAA,KAAAA,CAAMyB,eAAe,EAAA;AACrBH,QAAAA,KAAAA,CAAMtC,KAAK,GAAG,EAAA;AACda,QAAAA,OAAAA,CAAQoB,SAAS,CAAC;YAAEC,IAAAA,EAAM,OAAA;YAASC,IAAAA,EAAM;AAA2C,SAAA,CAAA;AACxF,IAAA,CAAA;AAEA,IAAA,MAAMO,aAAa,CAAC1B,KAAAA,GAAAA;AAChB,QAAA,IAAI,CAACN,OAAAA,EAAS;AACVM,YAAAA,KAAAA,CAAM2B,cAAc,EAAA;AACpB,YAAA;AACJ,QAAA;QACA,IAAI9B,OAAAA,CAAQ2B,IAAI,EAAE;AACdxB,YAAAA,KAAAA,CAAM2B,cAAc,EAAA;AACpB3B,YAAAA,KAAAA,CAAMyB,eAAe,EAAA;AACrB,YAAA;AACJ,QAAA;QAEA,IAAIjC,QAAAA,IAAY,CAACQ,KAAAA,CAAM4B,YAAY,EAAE1B,KAAAA,CAAMK,MAAAA,IAAU,CAAA,IAAK,CAAA,EAAG;AAC7DP,QAAAA,KAAAA,CAAM2B,cAAc,EAAA;AACpB3B,QAAAA,KAAAA,CAAMyB,eAAe,EAAA;AACrB5B,QAAAA,OAAAA,CAAQoB,SAAS,CAAC;YAAEC,IAAAA,EAAM,OAAA;YAASC,IAAAA,EAAM;AAA2C,SAAA,CAAA;AACxF,IAAA,CAAA;AAEA,IAAA,qBACIU,cAAA,CAACC,KAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAe7D,QAAQ8D,EAAE;QACzBC,sBAAAA,EAAqB,YAAA;AACrBC,QAAAA,OAAAA,EAAS/D,YAAAA,EAAc+D,OAAAA;AACvBC,QAAAA,aAAAA,EAAehE,YAAAA,EAAcgE,aAAAA;QAC7BC,eAAAA,EAAiBf,sBAAAA;QACjBgB,aAAAA,EAAeX,UAAAA;AACfY,QAAAA,iBAAAA,EAAmBtC,CAAAA,KAAAA,GAAAA;YAAW,IAAI,CAACN,OAAAA,EAASM,KAAAA,CAAM2B,cAAc,EAAA;AAAI,QAAA,CAAA;gCACpEE,cAAA,CAACU,sBAAWC,IAAI,EAAA;AACZC,YAAAA,MAAAA,EAAQvD,0BAAehB,OAAAA,EAAS,QAAA,CAAA;YAChCwE,IAAAA,EAAO9D,CAAAA,IAAAA,KAASC,6BAAAA,CAAe8D,IAAI,IAAI/D,IAAAA,KAASC,6BAAAA,CAAe+D,KAAI,KAAMhD,SAAAA;YACzEiD,YAAY,EAAA,IAAA;AACZC,YAAAA,QAAAA,EAAU,CAACpD,OAAAA;AACXqD,YAAAA,WAAAA,EAAaC,0BAAe9E,OAAAA,EAAS,aAAA,CAAA;YACrCsB,QAAAA,EAAUA,QAAAA;YACVyD,IAAAA,EAAM/D,yBAAAA,CAAehB,SAAS,MAAA,EAAQ,OAAA,CAAA;YACtCgF,aAAAA,EAAenD,QAAAA;YACfqB,QAAAA,EAAUf,OAAAA;oCACV8C,eAAA,CAACZ,sBAAWa,OAAO,EAAA;gBAACC,YAAAA,EAAYnE,yBAAAA,CAAehB,SAAS,WAAA,EAAa,uBAAA,CAAA;;kCACjE2D,cAAA,CAACyB,GAAAA,EAAAA;kCAAG1E,IAAAA,KAASC,6BAAAA,CAAe+D,KAAK,GAAG,0BAAA,GAA6B;;AACjE,kCAAAf,cAAA,CAACU,sBAAWgB,OAAO,EAAA;wBAACT,QAAAA,EAAU,CAACpD,OAAAA,IAAWG,OAAAA,CAAQ2B,IAAI;kCAAG5C,IAAAA,KAASC,6BAAAA,CAAe+D,KAAK,GAAG,aAAA,GAAgB;;AACxGhE,oBAAAA,IAAAA,KAASC,6BAAAA,CAAeC,QAAQ,kBAC7B+C,cAAA,CAACU,sBAAWiB,MAAM,EAAA;AAACV,wBAAAA,QAAAA,EAAU,CAACpD,OAAAA,IAAW,CAACE,SAAAA,IAAaC,QAAQ2B,IAAI;AAAE,wBAAA,QAAA,EAAA;;oBAExE,CAAC/C,cAAAA,CAAeM,OAAO,kBAAI8C,cAAA,CAACyB,GAAAA,EAAAA;wBAAEG,IAAAA,EAAK,OAAA;wBAAQC,kBAAAA,EAAiB,kBAAA;AAAoBjF,wBAAAA,QAAAA,EAAAA,cAAAA,CAAesC;;oBAC/F,CAAC5B,MAAAA,CAAOJ,OAAO,kBAAI8C,cAAA,CAACyB,GAAAA,EAAAA;wBAAEG,IAAAA,EAAK,OAAA;wBAAQC,kBAAAA,EAAiB,iBAAA;AAAmBvE,wBAAAA,QAAAA,EAAAA,MAAAA,CAAO4B;;AAC9E5B,oBAAAA,MAAAA,CAAOJ,OAAO,IAAI,CAACa,SAAAA,kBAAaiC,cAAA,CAACyB,GAAAA,EAAAA;wBAAEG,IAAAA,EAAK,QAAA;AAAS,wBAAA,QAAA,EAAA;;oBACjD5D,OAAAA,CAAQ2B,IAAI,kBAAIK,cAAA,CAACyB,GAAAA,EAAAA;wBAAEG,IAAAA,EAAK,QAAA;AAAS,wBAAA,QAAA,EAAA;;oBACjC5D,OAAAA,CAAQ8D,MAAM,KAAKhG,SAAAA,kBAAakE,cAAA,CAACyB,GAAAA,EAAAA;AAAEG,wBAAAA,IAAAA,EAAM5D,QAAQ8D,MAAM,CAACzC,IAAI,KAAK,UAAU,OAAA,GAAU,QAAA;kCAAWrB,OAAAA,CAAQ8D,MAAM,CAACxC;;;;;;AAKpI;;"}

package/dist/cjs/file/postFiles.js

@@ -0,0 +1,31 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Sends files to an address as a `multipart/form-data` POST.
+ *
+ * Cookies are sent only to the page's own origin (`credentials: 'same-origin'`), so an upload to another
+ * origin the host allowed carries no credentials. A redirect fails the upload rather than being followed,
+ * because following one would send the files to an address the origin policy never checked.
+ *
+ * @param url The address, already checked by `resolveUploadTarget`.
+ * @param field The multipart field name each file is appended under.
+ * @param files The files to send.
+ * @param signal Cancels the request.
+ * @throws When the request fails or the server does not answer with a success status.
+ */ async function postFiles(url, field, files, signal) {
+    const body = new FormData();
+    for (const file of files)body.append(field, file, file.name);
+    const response = await fetch(url, {
+        method: 'POST',
+        body,
+        credentials: 'same-origin',
+        redirect: 'error',
+        signal
+    });
+    if (!response.ok) throw new Error(`The server answered ${response.status}${response.statusText === '' ? '' : ` ${response.statusText}`}.`);
+}
+
+exports.postFiles = postFiles;
+//# sourceMappingURL=postFiles.js.map

package/dist/cjs/file/postFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postFiles.js","sources":["../../../file/postFiles.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/**\n * Sends files to an address as a `multipart/form-data` POST.\n *\n * Cookies are sent only to the page's own origin (`credentials: 'same-origin'`), so an upload to another\n * origin the host allowed carries no credentials. A redirect fails the upload rather than being followed,\n * because following one would send the files to an address the origin policy never checked.\n *\n * @param url The address, already checked by `resolveUploadTarget`.\n * @param field The multipart field name each file is appended under.\n * @param files The files to send.\n * @param signal Cancels the request.\n * @throws When the request fails or the server does not answer with a success status.\n */\nexport async function postFiles(url: string, field: string, files: File[], signal: AbortSignal): Promise<void> {\n    const body = new FormData();\n    for (const file of files) body.append(field, file, file.name);\n\n    const response = await fetch(url, { method: 'POST', body, credentials: 'same-origin', redirect: 'error', signal });\n    if (!response.ok) throw new Error(`The server answered ${response.status}${response.statusText === '' ? '' : ` ${response.statusText}`}.`);\n}\n"],"names":["postFiles","url","field","files","signal","body","FormData","file","append","name","response","fetch","method","credentials","redirect","ok","Error","status","statusText"],"mappings":";;AAAA;AACA;AAEA;;;;;;;;;;;;IAaO,eAAeA,SAAAA,CAAUC,GAAW,EAAEC,KAAa,EAAEC,KAAa,EAAEC,MAAmB,EAAA;AAC1F,IAAA,MAAMC,OAAO,IAAIC,QAAAA,EAAAA;IACjB,KAAK,MAAMC,QAAQJ,KAAAA,CAAOE,IAAAA,CAAKG,MAAM,CAACN,KAAAA,EAAOK,IAAAA,EAAMA,IAAAA,CAAKE,IAAI,CAAA;IAE5D,MAAMC,QAAAA,GAAW,MAAMC,KAAAA,CAAMV,GAAAA,EAAK;QAAEW,MAAAA,EAAQ,MAAA;AAAQP,QAAAA,IAAAA;QAAMQ,WAAAA,EAAa,aAAA;QAAeC,QAAAA,EAAU,OAAA;AAASV,QAAAA;AAAO,KAAA,CAAA;IAChH,IAAI,CAACM,QAAAA,CAASK,EAAE,EAAE,MAAM,IAAIC,KAAAA,CAAM,CAAC,oBAAoB,EAAEN,QAAAA,CAASO,MAAM,CAAA,EAAGP,SAASQ,UAAU,KAAK,EAAA,GAAK,EAAA,GAAK,CAAC,CAAC,EAAER,QAAAA,CAASQ,UAAU,CAAA,CAAE,CAAC,CAAC,CAAC,CAAA;AAC7I;;"}

package/dist/cjs/file/resolveUploadTarget.js

@@ -0,0 +1,68 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** A scheme (`https:`) or a protocol-relative prefix (`//host`): the address names its own host. */ const namesItsOwnHost = /^([a-z][a-z0-9+.-]*:|\/\/)/i;
+/** Whitespace, control characters and backslashes, which browsers normalize in ways that disguise another host. */ const disguisesAHost = (address)=>Array.from(address).some((character)=>character <= ' ' || character === '\u007f' || character === '\\');
+/** Resolved against, to read an address's own parts without depending on a page. It is never sent to. */ const placeholderOrigin = 'https://upload-target.invalid';
+/**
+ * Checks the address an authored upload sends files to.
+ *
+ * The address comes from authored model data, so it is not trusted. By default an upload may only go to the
+ * origin the page was served from - a relative address, or an absolute one with the same origin. A host that
+ * needs another origin names it in `allowedOrigins` when it provides the upload handler. Whatever is accepted
+ * has the scheme `http:` or `https:`, carries no user information, and contains no whitespace, control
+ * characters or backslashes, because those are how an address is made to point somewhere other than where it
+ * reads.
+ *
+ * @param url The authored address, if any.
+ * @param pageOrigin The origin of the page, `undefined` where there is no page (server rendering).
+ * @param allowedOrigins The additional origins the host permits.
+ * @returns The address to send to, or why it cannot be used.
+ */ function resolveUploadTarget(url, pageOrigin, allowedOrigins) {
+    if (url === undefined || url === '') return {
+        isValid: true,
+        url: undefined
+    };
+    if (disguisesAHost(url)) return refused('it contains whitespace, control characters or a backslash');
+    let resolved;
+    try {
+        resolved = new URL(url, placeholderOrigin);
+    } catch  {
+        return refused('it is not a valid address');
+    }
+    if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:') return refused(`the ${resolved.protocol} scheme is not allowed`);
+    if (resolved.username !== '' || resolved.password !== '') return refused('it carries user information');
+    if (!namesItsOwnHost.test(url)) return {
+        isValid: true,
+        url
+    };
+    const permitted = [
+        ...pageOrigin === undefined ? [] : [
+            pageOrigin
+        ],
+        ...allowedOrigins.flatMap(originOf)
+    ];
+    return permitted.includes(resolved.origin) ? {
+        isValid: true,
+        url: resolved.href
+    } : refused(`${resolved.origin} is not the origin of this page or one the host allows`);
+}
+function originOf(address) {
+    try {
+        return [
+            new URL(address).origin
+        ];
+    } catch  {
+        return [];
+    }
+}
+function refused(reason) {
+    return {
+        isValid: false,
+        message: `The upload address is not allowed: ${reason}.`
+    };
+}
+
+exports.resolveUploadTarget = resolveUploadTarget;
+//# sourceMappingURL=resolveUploadTarget.js.map

package/dist/cjs/file/resolveUploadTarget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveUploadTarget.js","sources":["../../../file/resolveUploadTarget.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { UploadTarget } from './UploadTarget';\n\n/** A scheme (`https:`) or a protocol-relative prefix (`//host`): the address names its own host. */\nconst namesItsOwnHost = /^([a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\n/** Whitespace, control characters and backslashes, which browsers normalize in ways that disguise another host. */\nconst disguisesAHost = (address: string) => Array.from(address).some(character => character <= ' ' || character === '\\u007f' || character === '\\\\');\n\n/** Resolved against, to read an address's own parts without depending on a page. It is never sent to. */\nconst placeholderOrigin = 'https://upload-target.invalid';\n\n/**\n * Checks the address an authored upload sends files to.\n *\n * The address comes from authored model data, so it is not trusted. By default an upload may only go to the\n * origin the page was served from - a relative address, or an absolute one with the same origin. A host that\n * needs another origin names it in `allowedOrigins` when it provides the upload handler. Whatever is accepted\n * has the scheme `http:` or `https:`, carries no user information, and contains no whitespace, control\n * characters or backslashes, because those are how an address is made to point somewhere other than where it\n * reads.\n *\n * @param url The authored address, if any.\n * @param pageOrigin The origin of the page, `undefined` where there is no page (server rendering).\n * @param allowedOrigins The additional origins the host permits.\n * @returns The address to send to, or why it cannot be used.\n */\nexport function resolveUploadTarget(url: string | undefined, pageOrigin: string | undefined, allowedOrigins: readonly string[]): UploadTarget {\n    if (url === undefined || url === '') return { isValid: true, url: undefined };\n    if (disguisesAHost(url)) return refused('it contains whitespace, control characters or a backslash');\n\n    let resolved: URL;\n    try {\n        resolved = new URL(url, placeholderOrigin);\n    } catch {\n        return refused('it is not a valid address');\n    }\n\n    if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:') return refused(`the ${resolved.protocol} scheme is not allowed`);\n    if (resolved.username !== '' || resolved.password !== '') return refused('it carries user information');\n    if (!namesItsOwnHost.test(url)) return { isValid: true, url };\n\n    const permitted = [...(pageOrigin === undefined ? [] : [pageOrigin]), ...allowedOrigins.flatMap(originOf)];\n    return permitted.includes(resolved.origin)\n        ? { isValid: true, url: resolved.href }\n        : refused(`${resolved.origin} is not the origin of this page or one the host allows`);\n}\n\nfunction originOf(address: string): string[] {\n    try {\n        return [new URL(address).origin];\n    } catch {\n        return [];\n    }\n}\n\nfunction refused(reason: string): UploadTarget {\n    return { isValid: false, message: `The upload address is not allowed: ${reason}.` };\n}\n"],"names":["namesItsOwnHost","disguisesAHost","address","Array","from","some","character","placeholderOrigin","resolveUploadTarget","url","pageOrigin","allowedOrigins","undefined","isValid","refused","resolved","URL","protocol","username","password","test","permitted","flatMap","originOf","includes","origin","href","reason","message"],"mappings":";;AAAA;AACA;AAIA,qGACA,MAAMA,eAAAA,GAAkB,6BAAA;AAExB,oHACA,MAAMC,cAAAA,GAAiB,CAACC,OAAAA,GAAoBC,MAAMC,IAAI,CAACF,OAAAA,CAAAA,CAASG,IAAI,CAACC,CAAAA,SAAAA,GAAaA,aAAa,GAAA,IAAOA,SAAAA,KAAc,YAAYA,SAAAA,KAAc,IAAA,CAAA;AAE9I,0GACA,MAAMC,iBAAAA,GAAoB,+BAAA;AAE1B;;;;;;;;;;;;;;AAcC,IACM,SAASC,mBAAAA,CAAoBC,GAAuB,EAAEC,UAA8B,EAAEC,cAAiC,EAAA;AAC1H,IAAA,IAAIF,GAAAA,KAAQG,SAAAA,IAAaH,GAAAA,KAAQ,EAAA,EAAI,OAAO;QAAEI,OAAAA,EAAS,IAAA;QAAMJ,GAAAA,EAAKG;AAAU,KAAA;IAC5E,IAAIX,cAAAA,CAAeQ,GAAAA,CAAAA,EAAM,OAAOK,OAAAA,CAAQ,2DAAA,CAAA;IAExC,IAAIC,QAAAA;IACJ,IAAI;QACAA,QAAAA,GAAW,IAAIC,IAAIP,GAAAA,EAAKF,iBAAAA,CAAAA;AAC5B,IAAA,CAAA,CAAE,OAAM;AACJ,QAAA,OAAOO,OAAAA,CAAQ,2BAAA,CAAA;AACnB,IAAA;AAEA,IAAA,IAAIC,SAASE,QAAQ,KAAK,OAAA,IAAWF,QAAAA,CAASE,QAAQ,KAAK,QAAA,EAAU,OAAOH,OAAAA,CAAQ,CAAC,IAAI,EAAEC,SAASE,QAAQ,CAAC,sBAAsB,CAAC,CAAA;IACpI,IAAIF,QAAAA,CAASG,QAAQ,KAAK,EAAA,IAAMH,SAASI,QAAQ,KAAK,EAAA,EAAI,OAAOL,OAAAA,CAAQ,6BAAA,CAAA;AACzE,IAAA,IAAI,CAACd,eAAAA,CAAgBoB,IAAI,CAACX,MAAM,OAAO;QAAEI,OAAAA,EAAS,IAAA;AAAMJ,QAAAA;AAAI,KAAA;AAE5D,IAAA,MAAMY,SAAAA,GAAY;WAAKX,UAAAA,KAAeE,SAAAA,GAAY,EAAE,GAAG;AAACF,YAAAA;AAAW,SAAA;AAAMC,QAAAA,GAAAA,cAAAA,CAAeW,OAAO,CAACC,QAAAA;AAAU,KAAA;AAC1G,IAAA,OAAOF,SAAAA,CAAUG,QAAQ,CAACT,QAAAA,CAASU,MAAM,CAAA,GACnC;QAAEZ,OAAAA,EAAS,IAAA;AAAMJ,QAAAA,GAAAA,EAAKM,SAASW;AAAK,KAAA,GACpCZ,QAAQ,CAAA,EAAGC,QAAAA,CAASU,MAAM,CAAC,sDAAsD,CAAC,CAAA;AAC5F;AAEA,SAASF,SAASrB,OAAe,EAAA;IAC7B,IAAI;QACA,OAAO;YAAC,IAAIc,GAAAA,CAAId,SAASuB;AAAO,SAAA;AACpC,IAAA,CAAA,CAAE,OAAM;AACJ,QAAA,OAAO,EAAE;AACb,IAAA;AACJ;AAEA,SAASX,QAAQa,MAAc,EAAA;IAC3B,OAAO;QAAEd,OAAAA,EAAS,KAAA;AAAOe,QAAAA,OAAAA,EAAS,CAAC,mCAAmC,EAAED,MAAAA,CAAO,CAAC;AAAE,KAAA;AACtF;;"}

package/dist/cjs/file/useUploadSession.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var react = require('react');
+var postFiles = require('./postFiles.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Runs one upload at a time for a control, through the host's handler or a POST to the checked address.
+ *
+ * Starting an upload while one runs is ignored rather than queued, so a double click cannot send the same
+ * files twice. Every failure ends in a visible `status`; none escapes as an unhandled rejection. An upload
+ * still running when the control unmounts is cancelled.
+ *
+ * @param handler The host's upload effect, if it owns the effect.
+ * @param url The checked address, if one was authored.
+ * @param field The multipart field name used when the control posts the files itself.
+ */ function useUploadSession(handler, url, field) {
+    const running = react.useRef(undefined);
+    const [busy, setBusy] = react.useState(false);
+    const [status, setStatus] = react.useState(undefined);
+    react.useEffect(()=>()=>running.current?.abort(), []);
+    const upload = react.useCallback(async (files)=>{
+        if (running.current !== undefined) return false;
+        const controller = new AbortController();
+        running.current = controller;
+        setBusy(true);
+        setStatus(undefined);
+        try {
+            if (handler !== undefined) await handler(files, url);
+            else if (url !== undefined) await postFiles.postFiles(url, field, files, controller.signal);
+            else throw new Error('There is nowhere to send the files.');
+            setStatus({
+                kind: 'success',
+                text: `${files.length} file${files.length === 1 ? '' : 's'} uploaded.`
+            });
+            return true;
+        } catch (error) {
+            if (!controller.signal.aborted) setStatus({
+                kind: 'error',
+                text: `Upload failed: ${error instanceof Error ? error.message : String(error)}`
+            });
+            return false;
+        } finally{
+            running.current = undefined;
+            setBusy(false);
+        }
+    }, [
+        handler,
+        url,
+        field
+    ]);
+    return {
+        busy,
+        status,
+        setStatus,
+        upload
+    };
+}
+
+exports.useUploadSession = useUploadSession;
+//# sourceMappingURL=useUploadSession.js.map

package/dist/cjs/file/useUploadSession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUploadSession.js","sources":["../../../file/useUploadSession.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { FileUploadHandler } from './FileUploadHandler';\nimport { UploadStatus } from './UploadStatus';\nimport { postFiles } from './postFiles';\n\n/** The state of the upload in flight, if any, and the action that starts one. */\nexport interface UploadSession {\n    /** Whether an upload is running. */\n    busy: boolean;\n\n    /** The last result, or `undefined` before the first upload and after a new selection. */\n    status: UploadStatus | undefined;\n    setStatus(status: UploadStatus | undefined): void;\n\n    /**\n     * Sends the files, unless an upload is already running.\n     *\n     * @returns Whether the files were sent, so the caller knows to clear its selection. A failure is reported\n     * through `status` and returns `false`: the selection stays so it can be retried.\n     */\n    upload(files: File[]): Promise<boolean>;\n}\n\n/**\n * Runs one upload at a time for a control, through the host's handler or a POST to the checked address.\n *\n * Starting an upload while one runs is ignored rather than queued, so a double click cannot send the same\n * files twice. Every failure ends in a visible `status`; none escapes as an unhandled rejection. An upload\n * still running when the control unmounts is cancelled.\n *\n * @param handler The host's upload effect, if it owns the effect.\n * @param url The checked address, if one was authored.\n * @param field The multipart field name used when the control posts the files itself.\n */\nexport function useUploadSession(handler: FileUploadHandler | undefined, url: string | undefined, field: string): UploadSession {\n    const running = useRef<AbortController | undefined>(undefined);\n    const [busy, setBusy] = useState(false);\n    const [status, setStatus] = useState<UploadStatus | undefined>(undefined);\n\n    useEffect(() => () => running.current?.abort(), []);\n\n    const upload = useCallback(async (files: File[]): Promise<boolean> => {\n        if (running.current !== undefined) return false;\n        const controller = new AbortController();\n        running.current = controller;\n        setBusy(true);\n        setStatus(undefined);\n        try {\n            if (handler !== undefined) await handler(files, url);\n            else if (url !== undefined) await postFiles(url, field, files, controller.signal);\n            else throw new Error('There is nowhere to send the files.');\n            setStatus({ kind: 'success', text: `${files.length} file${files.length === 1 ? '' : 's'} uploaded.` });\n            return true;\n        } catch (error) {\n            if (!controller.signal.aborted) setStatus({ kind: 'error', text: `Upload failed: ${error instanceof Error ? error.message : String(error)}` });\n            return false;\n        } finally {\n            running.current = undefined;\n            setBusy(false);\n        }\n    }, [handler, url, field]);\n\n    return { busy, status, setStatus, upload };\n}\n"],"names":["useUploadSession","handler","url","field","running","useRef","undefined","busy","setBusy","useState","status","setStatus","useEffect","current","abort","upload","useCallback","files","controller","AbortController","postFiles","signal","Error","kind","text","length","error","aborted","message","String"],"mappings":";;;;;AAAA;AACA;AAyBA;;;;;;;;;;AAUC,IACM,SAASA,gBAAAA,CAAiBC,OAAsC,EAAEC,GAAuB,EAAEC,KAAa,EAAA;AAC3G,IAAA,MAAMC,UAAUC,YAAAA,CAAoCC,SAAAA,CAAAA;AACpD,IAAA,MAAM,CAACC,IAAAA,EAAMC,OAAAA,CAAQ,GAAGC,cAAAA,CAAS,KAAA,CAAA;AACjC,IAAA,MAAM,CAACC,MAAAA,EAAQC,SAAAA,CAAU,GAAGF,cAAAA,CAAmCH,SAAAA,CAAAA;AAE/DM,IAAAA,eAAAA,CAAU,IAAM,IAAMR,OAAAA,CAAQS,OAAO,EAAEC,SAAS,EAAE,CAAA;IAElD,MAAMC,MAAAA,GAASC,kBAAY,OAAOC,KAAAA,GAAAA;AAC9B,QAAA,IAAIb,OAAAA,CAAQS,OAAO,KAAKP,SAAAA,EAAW,OAAO,KAAA;AAC1C,QAAA,MAAMY,aAAa,IAAIC,eAAAA,EAAAA;AACvBf,QAAAA,OAAAA,CAAQS,OAAO,GAAGK,UAAAA;QAClBV,OAAAA,CAAQ,IAAA,CAAA;QACRG,SAAAA,CAAUL,SAAAA,CAAAA;QACV,IAAI;AACA,YAAA,IAAIL,OAAAA,KAAYK,SAAAA,EAAW,MAAML,OAAAA,CAAQgB,KAAAA,EAAOf,GAAAA,CAAAA;iBAC3C,IAAIA,GAAAA,KAAQI,WAAW,MAAMc,mBAAAA,CAAUlB,KAAKC,KAAAA,EAAOc,KAAAA,EAAOC,WAAWG,MAAM,CAAA;AAC3E,iBAAA,MAAM,IAAIC,KAAAA,CAAM,qCAAA,CAAA;YACrBX,SAAAA,CAAU;gBAAEY,IAAAA,EAAM,SAAA;AAAWC,gBAAAA,IAAAA,EAAM,CAAA,EAAGP,KAAAA,CAAMQ,MAAM,CAAC,KAAK,EAAER,KAAAA,CAAMQ,MAAM,KAAK,CAAA,GAAI,EAAA,GAAK,GAAA,CAAI,UAAU;AAAE,aAAA,CAAA;YACpG,OAAO,IAAA;AACX,QAAA,CAAA,CAAE,OAAOC,KAAAA,EAAO;AACZ,YAAA,IAAI,CAACR,UAAAA,CAAWG,MAAM,CAACM,OAAO,EAAEhB,SAAAA,CAAU;gBAAEY,IAAAA,EAAM,OAAA;gBAASC,IAAAA,EAAM,CAAC,eAAe,EAAEE,KAAAA,YAAiBJ,QAAQI,KAAAA,CAAME,OAAO,GAAGC,MAAAA,CAAOH,KAAAA,CAAAA,CAAAA;AAAS,aAAA,CAAA;YAC5I,OAAO,KAAA;QACX,CAAA,QAAU;AACNtB,YAAAA,OAAAA,CAAQS,OAAO,GAAGP,SAAAA;YAClBE,OAAAA,CAAQ,KAAA,CAAA;AACZ,QAAA;IACJ,CAAA,EAAG;AAACP,QAAAA,OAAAA;AAASC,QAAAA,GAAAA;AAAKC,QAAAA;AAAM,KAAA,CAAA;IAExB,OAAO;AAAEI,QAAAA,IAAAA;AAAMG,QAAAA,MAAAA;AAAQC,QAAAA,SAAAA;AAAWI,QAAAA;AAAO,KAAA;AAC7C;;"}

package/dist/cjs/index.js

@@ -31,6 +31,17 @@ var PrimeChips = require('./form/PrimeChips.js');
 var PrimeAutoComplete = require('./form/PrimeAutoComplete.js');
 var TreeSelect = require('./form/TreeSelect.js');
 var PrimeTreeSelect = require('./form/PrimeTreeSelect.js');
+var PrimeEditor = require('./editor/PrimeEditor.js');
+var QuillLoaderProvider = require('./editor/QuillLoaderProvider.js');
+var htmlToPlainText = require('./editor/htmlToPlainText.js');
+var renderSafeNodes = require('./editor/renderSafeNodes.js');
+var safeUrls = require('./editor/safeUrls.js');
+var sanitizeHtml = require('./editor/sanitizeHtml.js');
+var serializeSafeNodes = require('./editor/serializeSafeNodes.js');
+var FileUploadHandlerProvider = require('./file/FileUploadHandlerProvider.js');
+var FileUploadMode = require('./file/FileUploadMode.js');
+var PrimeFileUpload = require('./file/PrimeFileUpload.js');
+var resolveUploadTarget = require('./file/resolveUploadTarget.js');
 var ChartType = require('./chart/ChartType.js');
 var PrimeChart = require('./chart/PrimeChart.js');
 var resolveChartType = require('./chart/resolveChartType.js');
@@ -45,6 +56,10 @@ var PrimePaginator = require('./data/PrimePaginator.js');
 var PrimeOrderList = require('./data/PrimeOrderList.js');
 var PrimePickList = require('./data/PrimePickList.js');
 var PrimeOrganizationChart = require('./data/PrimeOrganizationChart.js');
+var PrimeDataScroller = require('./data/PrimeDataScroller.js');
+var PrimeTreeTable = require('./data/PrimeTreeTable.js');
+var TreeTableSelectionMode = require('./data/TreeTableSelectionMode.js');
+var readableValue = require('./data/readableValue.js');
 var PrimeCard = require('./panel/PrimeCard.js');
 var PrimePanel = require('./panel/PrimePanel.js');
 var PrimeFieldset = require('./panel/PrimeFieldset.js');
@@ -129,6 +144,7 @@ exports.stringArrayProperty = properties.stringArrayProperty;
 exports.stringProperty = properties.stringProperty;
 exports.menuItemsProperty = menuItems.menuItemsProperty;
 exports.toMenuItems = menuItems.toMenuItems;
+exports.countUnreadableEntries = treeNodes.countUnreadableEntries;
 exports.toTreeNodes = treeNodes.toTreeNodes;
 exports.treeNodesProperty = treeNodes.treeNodesProperty;
 exports.PrimeButton = PrimeButton.PrimeButton;
@@ -159,6 +175,18 @@ exports.PrimeChips = PrimeChips.PrimeChips;
 exports.PrimeAutoComplete = PrimeAutoComplete.PrimeAutoComplete;
 exports.TreeSelect = TreeSelect.TreeSelect;
 exports.PrimeTreeSelect = PrimeTreeSelect.PrimeTreeSelect;
+exports.PrimeEditor = PrimeEditor.PrimeEditor;
+exports.QuillLoaderProvider = QuillLoaderProvider.QuillLoaderProvider;
+exports.htmlToPlainText = htmlToPlainText.htmlToPlainText;
+exports.renderSafeNodes = renderSafeNodes.renderSafeNodes;
+exports.safeImageUrl = safeUrls.safeImageUrl;
+exports.safeLinkUrl = safeUrls.safeLinkUrl;
+exports.sanitizeHtml = sanitizeHtml.sanitizeHtml;
+exports.serializeSafeNodes = serializeSafeNodes.serializeSafeNodes;
+exports.FileUploadHandlerProvider = FileUploadHandlerProvider.FileUploadHandlerProvider;
+exports.FileUploadMode = FileUploadMode.FileUploadMode;
+exports.PrimeFileUpload = PrimeFileUpload.PrimeFileUpload;
+exports.resolveUploadTarget = resolveUploadTarget.resolveUploadTarget;
 exports.ChartType = ChartType.ChartType;
 exports.PrimeChart = PrimeChart.PrimeChart;
 exports.legacyChartTypes = resolveChartType.legacyChartTypes;
@@ -174,6 +202,10 @@ exports.PrimePaginator = PrimePaginator.PrimePaginator;
 exports.PrimeOrderList = PrimeOrderList.PrimeOrderList;
 exports.PrimePickList = PrimePickList.PrimePickList;
 exports.PrimeOrganizationChart = PrimeOrganizationChart.PrimeOrganizationChart;
+exports.PrimeDataScroller = PrimeDataScroller.PrimeDataScroller;
+exports.PrimeTreeTable = PrimeTreeTable.PrimeTreeTable;
+exports.TreeTableSelectionMode = TreeTableSelectionMode.TreeTableSelectionMode;
+exports.readableValue = readableValue.readableValue;
 exports.PrimeCard = PrimeCard.PrimeCard;
 exports.PrimePanel = PrimePanel.PrimePanel;
 exports.PrimeFieldset = PrimeFieldset.PrimeFieldset;

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/legacyEnumerationChoices.js

@@ -0,0 +1,39 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The choices for an enumeration property: the stable values new documents use, then the ordinals migrated
+ * documents carry, then the Pascal case member names a serialized .NET enum produces. These are the same forms
+ * the renderer accepts, so a stored value the control draws is never flagged invalid by descriptor validation.
+ *
+ * A migrated control stores the original numeric value. Offering those ordinals keeps the stored value valid
+ * against the descriptor (so an inspector shows it as the current choice) without rewriting it behind the
+ * author's back. The position of a member in `members` is its ordinal.
+ *
+ * @param members The enum object.
+ * @param labels The label of each member, by canonical value.
+ * @returns The canonical choices, then one legacy choice per ordinal, then one per Pascal case member name.
+ */ function legacyEnumerationChoices(members, labels) {
+    const canonical = Object.values(members);
+    const names = Object.keys(members);
+    return [
+        ...canonical.map((member)=>({
+                value: member,
+                label: labels[member]
+            })),
+        ...canonical.map((member, ordinal)=>({
+                value: ordinal,
+                label: `${labels[member]} (legacy ${ordinal})`,
+                description: `The ordinal ${ordinal} of the original enum, as stored by migrated documents.`
+            })),
+        ...names.map((name)=>({
+                value: name,
+                label: `${labels[members[name]]} (legacy name ${name})`,
+                description: `The member name ${name} of the original enum, as a serialized enum stores it.`
+            }))
+    ];
+}
+
+exports.legacyEnumerationChoices = legacyEnumerationChoices;
+//# sourceMappingURL=legacyEnumerationChoices.js.map

package/dist/cjs/legacyEnumerationChoices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacyEnumerationChoices.js","sources":["../../legacyEnumerationChoices.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { PropertyChoice } from '@cratis/scene.model';\n\n/**\n * The choices for an enumeration property: the stable values new documents use, then the ordinals migrated\n * documents carry, then the Pascal case member names a serialized .NET enum produces. These are the same forms\n * the renderer accepts, so a stored value the control draws is never flagged invalid by descriptor validation.\n *\n * A migrated control stores the original numeric value. Offering those ordinals keeps the stored value valid\n * against the descriptor (so an inspector shows it as the current choice) without rewriting it behind the\n * author's back. The position of a member in `members` is its ordinal.\n *\n * @param members The enum object.\n * @param labels The label of each member, by canonical value.\n * @returns The canonical choices, then one legacy choice per ordinal, then one per Pascal case member name.\n */\nexport function legacyEnumerationChoices<TMember extends string>(members: Record<string, TMember>, labels: Record<TMember, string>): PropertyChoice[] {\n    const canonical = Object.values(members);\n    const names = Object.keys(members);\n    return [\n        ...canonical.map(member => ({ value: member, label: labels[member] })),\n        ...canonical.map((member, ordinal) => ({\n            value: ordinal,\n            label: `${labels[member]} (legacy ${ordinal})`,\n            description: `The ordinal ${ordinal} of the original enum, as stored by migrated documents.`,\n        })),\n        ...names.map(name => ({\n            value: name,\n            label: `${labels[members[name]]} (legacy name ${name})`,\n            description: `The member name ${name} of the original enum, as a serialized enum stores it.`,\n        })),\n    ];\n}\n"],"names":["legacyEnumerationChoices","members","labels","canonical","Object","values","names","keys","map","member","value","label","ordinal","description","name"],"mappings":";;AAAA;AACA;AAIA;;;;;;;;;;;;AAYC,IACM,SAASA,wBAAAA,CAAiDC,OAAgC,EAAEC,MAA+B,EAAA;IAC9H,MAAMC,SAAAA,GAAYC,MAAAA,CAAOC,MAAM,CAACJ,OAAAA,CAAAA;IAChC,MAAMK,KAAAA,GAAQF,MAAAA,CAAOG,IAAI,CAACN,OAAAA,CAAAA;IAC1B,OAAO;AACAE,QAAAA,GAAAA,SAAAA,CAAUK,GAAG,CAACC,CAAAA,MAAAA,IAAW;gBAAEC,KAAAA,EAAOD,MAAAA;gBAAQE,KAAAA,EAAOT,MAAM,CAACO,MAAAA;aAAQ,CAAA,CAAA;AAChEN,QAAAA,GAAAA,SAAAA,CAAUK,GAAG,CAAC,CAACC,MAAAA,EAAQG,WAAa;gBACnCF,KAAAA,EAAOE,OAAAA;gBACPD,KAAAA,EAAO,CAAA,EAAGT,MAAM,CAACO,MAAAA,CAAO,CAAC,SAAS,EAAEG,OAAAA,CAAQ,CAAC,CAAC;AAC9CC,gBAAAA,WAAAA,EAAa,CAAC,YAAY,EAAED,OAAAA,CAAQ,uDAAuD;aAC/F,CAAA,CAAA;AACGN,QAAAA,GAAAA,KAAAA,CAAME,GAAG,CAACM,CAAAA,IAAAA,IAAS;gBAClBJ,KAAAA,EAAOI,IAAAA;AACPH,gBAAAA,KAAAA,EAAO,CAAA,EAAGT,MAAM,CAACD,OAAO,CAACa,IAAAA,CAAK,CAAC,CAAC,cAAc,EAAEA,IAAAA,CAAK,CAAC,CAAC;AACvDD,gBAAAA,WAAAA,EAAa,CAAC,gBAAgB,EAAEC,IAAAA,CAAK,sDAAsD;aAC/F,CAAA;AACH,KAAA;AACL;;"}

package/dist/cjs/loadQuill/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The ready-made Quill loader: `() => import('quill')`.
+ *
+ * This entry point is the only place the package names `quill`, and it is separate from the package root on
+ * purpose. A host that renders editable rich text imports it, installs the `quill` peer dependency and
+ * Quill's stylesheet, and passes it to `QuillLoaderProvider`; every other host never resolves `quill`.
+ *
+ * ```tsx
+ * import 'quill/dist/quill.snow.css';
+ * import { QuillLoaderProvider } from '@cratis/scene.primereact';
+ * import { loadQuill } from '@cratis/scene.primereact/quill';
+ *
+ * <QuillLoaderProvider loader={loadQuill}>{screen}</QuillLoaderProvider>
+ * ```
+ */ const loadQuill = ()=>import('quill');
+
+exports.loadQuill = loadQuill;
+//# sourceMappingURL=index.js.map

package/dist/cjs/loadQuill/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../loadQuill/index.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport type { QuillLoader } from '../editor/QuillLoader';\n\n/**\n * The ready-made Quill loader: `() => import('quill')`.\n *\n * This entry point is the only place the package names `quill`, and it is separate from the package root on\n * purpose. A host that renders editable rich text imports it, installs the `quill` peer dependency and\n * Quill's stylesheet, and passes it to `QuillLoaderProvider`; every other host never resolves `quill`.\n *\n * ```tsx\n * import 'quill/dist/quill.snow.css';\n * import { QuillLoaderProvider } from '@cratis/scene.primereact';\n * import { loadQuill } from '@cratis/scene.primereact/quill';\n *\n * <QuillLoaderProvider loader={loadQuill}>{screen}</QuillLoaderProvider>\n * ```\n */\nexport const loadQuill: QuillLoader = () => import('quill') as unknown as ReturnType<QuillLoader>;\n"],"names":["loadQuill"],"mappings":";;AAAA;AACA;AAIA;;;;;;;;;;;;;;AAcC,IACM,MAAMA,SAAAA,GAAyB,IAAM,OAAO,OAAA;;"}

package/dist/cjs/primeReactComponents.js

@@ -20,6 +20,8 @@ var PrimePaginator = require('./data/PrimePaginator.js');
 var PrimeOrderList = require('./data/PrimeOrderList.js');
 var PrimePickList = require('./data/PrimePickList.js');
 var PrimeOrganizationChart = require('./data/PrimeOrganizationChart.js');
+var PrimeDataScroller = require('./data/PrimeDataScroller.js');
+var PrimeTreeTable = require('./data/PrimeTreeTable.js');
 var PrimeInputText = require('./form/PrimeInputText.js');
 var PrimeInputTextarea = require('./form/PrimeInputTextarea.js');
 var PrimeInputNumber = require('./form/PrimeInputNumber.js');
@@ -44,6 +46,10 @@ var PrimeAutoComplete = require('./form/PrimeAutoComplete.js');
 require('react');
 require('primereact/tree');
 var PrimeTreeSelect = require('./form/PrimeTreeSelect.js');
+var PrimeEditor = require('./editor/PrimeEditor.js');
+require('./editor/QuillLoaderContext.js');
+require('./file/FileUploadContext.js');
+var PrimeFileUpload = require('./file/PrimeFileUpload.js');
 var PrimeImage = require('./media/PrimeImage.js');
 var PrimeGalleria = require('./media/PrimeGalleria.js');
 var PrimeCarousel = require('./media/PrimeCarousel.js');
@@ -140,6 +146,8 @@ var PrimeAction = require('./screen/PrimeAction.js');
     [scene_react.componentRegistryKey('PrimeReact', 'chips')]: PrimeChips.PrimeChips,
     [scene_react.componentRegistryKey('PrimeReact', 'autoComplete')]: PrimeAutoComplete.PrimeAutoComplete,
     [scene_react.componentRegistryKey('PrimeReact', 'treeSelect')]: PrimeTreeSelect.PrimeTreeSelect,
+    [scene_react.componentRegistryKey('PrimeReact', 'editor')]: PrimeEditor.PrimeEditor,
+    [scene_react.componentRegistryKey('PrimeReact', 'fileUpload')]: PrimeFileUpload.PrimeFileUpload,
     [scene_react.componentRegistryKey('PrimeReact', 'button')]: PrimeButton.PrimeButton,
     [scene_react.componentRegistryKey('PrimeReact', 'splitButton')]: PrimeSplitButton.PrimeSplitButton,
     [scene_react.componentRegistryKey('PrimeReact', 'speedDial')]: PrimeSpeedDial.PrimeSpeedDial,
@@ -148,7 +156,9 @@ var PrimeAction = require('./screen/PrimeAction.js');
     [scene_react.componentRegistryKey('PrimeReact', 'table')]: PrimeDataTable.PrimeDataTable,
     [scene_react.componentRegistryKey('PrimeReact', 'column')]: PrimeColumn.PrimeColumn,
     [scene_react.componentRegistryKey('PrimeReact', 'dataView')]: PrimeDataView.PrimeDataView,
+    [scene_react.componentRegistryKey('PrimeReact', 'dataScroller')]: PrimeDataScroller.PrimeDataScroller,
     [scene_react.componentRegistryKey('PrimeReact', 'tree')]: PrimeTree.PrimeTree,
+    [scene_react.componentRegistryKey('PrimeReact', 'treeTable')]: PrimeTreeTable.PrimeTreeTable,
     [scene_react.componentRegistryKey('PrimeReact', 'timeline')]: PrimeTimeline.PrimeTimeline,
     [scene_react.componentRegistryKey('PrimeReact', 'paginator')]: PrimePaginator.PrimePaginator,
     [scene_react.componentRegistryKey('PrimeReact', 'orderList')]: PrimeOrderList.PrimeOrderList,