@instructure/canvas-rce 5.15.4 → 5.15.5

package/es/translations/locales/mn_MN.d.ts

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

package/es/translations/locales/ms.d.ts

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

package/es/translations/locales/nb-x-k12.d.ts

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

package/es/translations/locales/nb.d.ts

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

package/es/translations/locales/nl.d.ts

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

package/es/translations/locales/nl_NL.d.ts

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

package/es/translations/locales/nn.d.ts

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

package/es/translations/locales/pl.d.ts

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

package/es/translations/locales/pt.d.ts

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

package/es/translations/locales/pt_BR.d.ts

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

package/es/translations/locales/ro.d.ts

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

package/es/translations/locales/ru.d.ts

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

package/es/translations/locales/se.d.ts

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

package/es/translations/locales/sl.d.ts

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

package/es/translations/locales/sv-x-k12.d.ts

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

package/es/translations/locales/sv.d.ts

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

package/es/translations/locales/sv_SE.d.ts

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

package/es/translations/locales/tg.d.ts

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

package/es/translations/locales/th.d.ts

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

package/es/translations/locales/th_TH.d.ts

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

package/es/translations/locales/tl_PH.d.ts

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

package/es/translations/locales/tr.d.ts

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

package/es/translations/locales/uk_UA.d.ts

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

package/es/translations/locales/vi.d.ts

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

package/es/translations/locales/vi_VN.d.ts

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

package/es/translations/locales/zh-Hans.d.ts

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

package/es/translations/locales/zh-Hant.d.ts

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

package/es/translations/locales/zh.d.ts

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

package/es/translations/locales/zh_HK.d.ts

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

package/es/translations/locales/zh_TW.Big5.d.ts

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

package/es/translations/locales/zh_TW.d.ts

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

package/es/util/DeepPartialNullable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Helper type that takes an input Record type and produces a copy where all properties are optional and nullable,
+ * recursively.
+ *
+ * Useful for declaring the type of unsafe input JSON to ensure that proper null checking is handled.
+ */
+export type DeepPartialNullable<T> = {
+    [K in keyof T]?: (T[K] extends object ? DeepPartialNullable<T[K]> : T[K]) | null;
+};
+/**
+ * Implementation of DeepPartial that handles children that may be optional or nullable.
+ */
+export type DeepPartialOptional<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartialOptional<T[K]> : T[K] extends object | null ? DeepPartialOptional<T[K]> | null : T[K] extends object | undefined ? DeepPartialOptional<T[K]> | undefined : T[K] extends object | null | undefined ? DeepPartialOptional<T[K]> | null | undefined : T[K];
+};

package/es/util/ExtractRequired.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Extract from `T` those types that are assignable to `U`, but only allows values present in `T`
+ *
+ * This is a more type safe version of the built-in `Extract`.
+ *
+ *
+ * @example
+ * // Imagine a type encoding the valid CSS border-style values:
+ *
+ * type CssBorderStyle = 'dotted'
+ *                     | 'dashed'
+ *                     | 'solid'
+ *                     | 'double'
+ *                     | 'groove'
+ *                     | 'ridge'
+ *                     | 'inset'
+ *                     | 'outset'
+ *                     | 'none'
+ *                     | 'hidden'
+ *
+ *
+ * // We might want to have a function that only supports a subset of that list, but we want the compiler to ensure
+ * // we didn't make a mistake. The following would compile:
+ *
+ *
+ * function applyValidBorder(
+ *   style: ExtractRequired<CssBorderStyle, 'solid' | 'none' | 'dashed'>
+ * ){  }
+ *
+ *
+ * // But this would not compile, since 'unsolid' isn't in `CssBorderStyle`:
+ *
+ *
+ * function applyValidBorder(
+ *   style: ExtractRequired<CssBorderStyle, 'unsolid' | 'none' | 'dashed'>
+ * ) {  }
+ *
+ *
+ * // This is helpful if a value is later removed from `CssBorderStyle`: All uses of that value will become compiler
+ * // errors.
+ */
+export type ExtractRequired<TSuperset, TSubset extends TSuperset> = TSuperset extends TSubset ? TSuperset : never;

package/es/util/TypedDict.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Takes a dictionary with explicit keys and returns an object with three type-safe properties:
+ *
+ * - `byKey`: The original dictionary, but with the key of each value added to it as `[keyProp]`
+ * - `values`: An array of the values in the original dictionary
+ * - `keys`: An array of the keys in the original dictionary
+ * - `TKey`: A placeholder value that holds the type of the keys
+ * - `TValue`: A placeholder value that holds the type of the values
+ *
+ * This is useful to add explicit type checking to the pattern where a literal dictionary is used to define
+ * a relationship between a known set of keys to some value type.
+ *
+ * For example:
+ *
+ * ```
+ * const {
+ *   byKey: itemDict,
+ *   values: items,
+ *   keys: itemSlugs,
+ * } = typedKeyDict(
+ *   {
+ *     undo: {
+ *       label: 'Undo',
+ *       description: 'Undo the last action',
+ *       performAction: () => {
+ *         // Do work
+ *       },
+ *     },
+ *     redo: {
+ *       label: 'Redo',
+ *       description: 'Redo the last undone action, or repeat the last action',
+ *       performAction: () => {
+ *         // Do work
+ *       },
+ *     },
+ *   },
+ *   'slug'
+ * )
+ *
+ * // Values of itemDict now have a `slug` property with type `'undo' | 'redo'`
+ *
+ * const slug: 'undo' | 'redo' = itemDict.undo.slug
+ *
+ * // Key and value iteration are now type safe:
+ *
+ * items.forEach(item => {
+ *   // item is the correct type, unlike what Object.values gives
+ * })
+ *
+ * itemSlugs.forEach(slug => {
+ *   // slug is the correct type ('undo' | 'redo'), unlike what Object.values gives
+ * })
+ *
+ * ```
+ *
+ * Additionally, explicit type arguments can be provided, ensuring that an interface is implemented, or that all keys
+ * in a union type are implemented.
+ *
+ * For example:
+ *
+ * ```
+ * type ItemSlug = 'undo' | 'redo'
+ *
+ * interface ActionItem {
+ *   label: string
+ *   description: string
+ *   performAction: () => void
+ * }
+ *
+ * typedKeyDict<ItemSlug, ActionItem, 'slug'>(
+ *   {
+ *     undo: {
+ *       label: 'Undo',
+ *       description: 'Undo the last action',
+ *       performAction: () => {
+ *         // Do work
+ *       },
+ *     },
+ *   },
+ *   'key'
+ * )
+ * ```
+ *
+ * Will not compile, because `redo` is not specified in the map, but is defined as a valid value for `ItemSlug`.
+ * This can be very helpful if `ItemSlug` is defined in another file. Adding an additional key to it will force
+ * you to fix anywhere it is used in this way.
+ *
+ * @param dict The input dictionary
+ * @param keyProp The name of the property to add to the resulting objects containing the key for each value. Defaults to 'key'
+ */
+export declare function typedKeyDict<TKey extends string, TValue extends object, TKeyProp extends string = 'key'>(dict: {
+    [key in TKey]: Omit<TValue, TKeyProp>;
+}, keyProp?: TKeyProp): {
+    byKey: Record<TKey, TValue & Record<TKeyProp, TKey>>;
+    keys: Array<TKey>;
+    values: Array<TValue & Record<TKeyProp, TKey>>;
+    TKey: TKey;
+    TValue: TValue & Record<TKeyProp, TKey>;
+};

package/es/util/assertNever.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Used to ensure in a type safe way that some variable cannot ever be in a particular state.
+ * Useful for exhaustive switch statements, where the compiler will ensure all possible cases are covered.
+ *
+ * For example:
+ *
+ * ```
+ * const someValue: 'a' | 'b' = ...
+ *
+ * switch (someValue) {
+ *   case 'a': return whatever();
+ *   case 'b': return whatever();
+ *
+ *   // If all possible values of someValue aren't handled above, this will fail to compile
+ *   default: assertNever(someValue);
+ * }
+ *
+ * ```
+ *
+ * Inspired by https://stackoverflow.com/questions/39419170/how-do-i-check-that-a-switch-block-is-exhaustive-in-typescript
+ *
+ * @param input
+ */
+export declare function assertNever(input: never): never;

package/es/util/elem-util.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility function to check if a node is Text in a typesafe manner to allow TypeScript type narrowing.
+ *
+ * @param n
+ */
+export declare function isTextNode(n: Node | null | undefined): n is Text;

package/es/util/encrypted-storage.d.ts

@@ -0,0 +1,9 @@
+export default class EncryptedStorage {
+    passphrase: import("crypto-es/lib/core").WordArray;
+    constructor(passphrase: string);
+    setItem(key: string, content: string): void | null;
+    getItem(key: string): any;
+    key(index: number): string | null;
+    removeItem(key: string): void | null;
+    errorHandlerWrapper: <T>(callback: () => T) => T | null;
+}

package/es/util/file-url-util.d.ts

@@ -0,0 +1 @@
+export declare function guessCanvasFileIdFromUrl(inputUrlStr: string, restrictToOrigin?: string | null): string | null;

package/es/util/fullscreenHelpers.d.ts

@@ -0,0 +1,6 @@
+export declare const FS_ELEMENT: string;
+export declare const FS_REQUEST: string;
+export declare const FS_EXIT: string;
+export declare const FS_CHANGEEVENT: string;
+export declare const FS_ENABLED: string;
+export declare const instuiPopupMountNodeFn: () => HTMLElement | null | undefined;

package/es/util/instui-icon-helper.d.ts

@@ -0,0 +1,19 @@
+/**
+ * All inst-ui icons as an array.
+ *
+ * Note that this does require including these all in the built modules, but it appears that they were already
+ * present, as testing with and without this didn't yield much difference in module size.
+ */
+export declare const instUiIconsArray: Array<InstUiIcon>;
+/**
+ * Type for inst ui icons
+ */
+export interface InstUiIcon {
+    variant: 'Line' | 'Solid';
+    glyphName: string;
+    /**
+     * SVG code for the icon
+     */
+    src: string;
+    deprecated: boolean;
+}

package/es/util/loadingPlaceholder.d.ts

@@ -0,0 +1,39 @@
+import { Editor } from 'tinymce';
+/**
+ * Determines what type of placeholder is appropriate for a given file information.
+ */
+export declare function placeholderInfoFor(fileMetaProps: PlaceHoldableThingInfo): Promise<PlaceholderInfo>;
+export declare function removePlaceholder(editor: Editor, unencodedName: string): void;
+/**
+ * Inserts a placeholder into a TinyMCE editor. It should be removed by calling removePlaceholder, to ensure
+ * image resources are cleaned up.
+ */
+export declare function insertPlaceholder(editor: Editor, unencodedName: string | undefined, placeholderInfoPromise: Promise<PlaceholderInfo>): Promise<HTMLElement>;
+/**
+ * Something for which a placeholder can be added to the editor.
+ */
+export interface PlaceHoldableThingInfo {
+    name?: string;
+    type?: string;
+    title?: string;
+    contentType?: string;
+    displayAs?: 'link' | string;
+    domObject: File | Blob | {
+        preview?: string;
+    };
+}
+/**
+ * Style of placeholder to be inserted into the editor.
+ */
+export type PlaceholderInfo = {
+    visibleLabel: string;
+    ariaLabel: string;
+} & ({
+    type: 'inline';
+} | {
+    type: 'block';
+    backgroundImageUrl?: string;
+    width: string;
+    height: string;
+    vAlign: string;
+});

package/es/util/simpleCache.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Builds a simple cache using a map and a compute function.
+ *
+ * @param compute The function to compute values in the cache
+ * @param cache The map to use as a cache
+ */
+export declare function simpleCache<K, V>(compute: (value: K) => V, cache?: Map<K, V>): SimpleCache<K, V>;
+export interface SimpleCache<K, V> {
+    cache: Map<K, V>;
+    get(key: K): V;
+}

package/es/util/string-util.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns null if the string is null, undefined, or has length === 0
+ *
+ * @param str
+ */
+export declare function emptyAsNull(str: string | null | undefined): string | null;
+/**
+ * Returns null if the string is null, undefined, is empty, or contains only whitespace.
+ *
+ * Otherwise returns the string with leading and trailing whitespace removed.
+ *
+ * Useful for providing a default value for a string input:
+ *
+ * ```
+ * label.innerText = trimmedOrNull(input.value) ?? 'Default value'
+ * ```
+ *
+ * @param str
+ */
+export declare function trimmedOrNull(str: string | null | undefined): string | null;

package/es/util/textarea-editing-util.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Represents a subset of the editing actions that can be taken on a <textarea> using the text-field-edit library.
+ *
+ * This is used to allow decoupling logic that requires textarea editing from the actual commands, because it's tricky
+ * to test code that uses the 'text-field-edit' library directly, since it relies on document.execCommand().
+ *
+ * For production code, actions can be executed on a <textarea> using performTextEditActionOnTextarea
+ * For testing, actions can be executed on a string using performTextEditActionsOnString
+ */
+export type TextEditAction = {
+    action: 'insert';
+    text: string;
+} | {
+    action: 'wrapSelection';
+    before: string | null | undefined;
+    after: string | null | undefined;
+};
+/**
+ * Executes the given text edit actions on a <textarea>
+ */
+export declare function performTextEditActionOnTextarea(textarea: HTMLTextAreaElement, editAction: TextEditAction): void;
+/**
+ * Executes the given text edit actions on an object representing the important state of textarea editing,
+ * the current text, selection start, and selection end.
+ */
+export declare function performTextEditActionsOnString(args: {
+    text: string;
+    selStart: number;
+    selEnd: number;
+    actions: TextEditAction[];
+}): {
+    text: string;
+    selStart: number;
+    selEnd: number;
+};

package/es/util/tinymce-plugin-util.d.ts

@@ -0,0 +1,16 @@
+import { Editor } from 'tinymce';
+/**
+ * Returns a helper for updating the icon of a toolbar button in a TinyMCE editor, necessary since there isn't a
+ * built-in API for doing this, and RCE UX calls for toolbar buttons to be updated to match the user's selection
+ * in the editor.
+ *
+ *
+ * NOTE:
+ * This function returns a helper that can later be used to actually update the icon. This is done so that
+ * `toolbarIconHelperFor` can be called in the `onSetup` method of a button, such that any errors in finding the
+ * icon in the toolbar will occur at RCE setup time, and not later, when user action occurs, thus increasing the
+ * likelihood that those errors will be caught in tests, rather than being thrown at runtime as a result of user action
+ */
+export declare function toolbarIconHelperFor(editor: Editor, ariaLabel: string): {
+    updateIcon(iconName: string): void;
+};

package/es/util/url-util.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Attempts to build a URL from the given string, and returns null if it is not a valid URL, rather than
+ * throwing an exception, as the URL constructor does.
+ */
+export declare function parseUrlOrNull(url: string | null | undefined, base?: string | URL): URL | null;
+export declare function relativizeUrl(url: string): string;
+export declare function parseUrlPath(url: string): string | undefined;
+/**
+ * Converts the given URL into a relative URL if it meets the following criteria:
+ * - is parsable by the browser URL class
+ * - has the HTTP or HTTPS protocol
+ * - has the same hostname as the given origin
+ *
+ * Note: This will relativize URLs where the ports don't match. This is intentional, as ports really shouldn't
+ * matter for RCE HTTP content, and it can solve issues where an extraneous port is added (e.g. :80 on an http url)
+ * or when running locally and the port is different. There isn't a security issue because the user could just manually
+ * put in the transformed content anyways.
+ *
+ * @param inputUrlStr URL to relativize
+ * @param origin Origin to check for
+ */
+export declare function relativeHttpUrlForHostname<TInput extends string | null | undefined>(inputUrlStr: TInput, origin: string): TInput;
+/**
+ * Adds a record of query parameters to a URL. null or undefined values in the record are ignored.
+ *
+ * - Relative URLs are supported.
+ * - Non-parsable URLs will return null.
+ *
+ * @param inputUrlStr The URL string to parse
+ * @param queryParams A record containing the query parameters to add
+ */
+export declare function addQueryParamsToUrl(inputUrlStr: string | null | undefined, queryParams: Record<string, string | null | undefined>): string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instructure/canvas-rce",
-  "version": "5.15.4",
+  "version": "5.15.5",
   "description": "A component wrapping Canvas's usage of Tinymce",
   "main": "es/index.js",
   "types": "es/index.d.ts",
@@ -31,13 +31,12 @@
     "installTranslations": "scripts/installTranslations.js",
     "commitTranslations": "scripts/commitTranslations.sh",
     "build": "scripts/build-canvas",
-    "build:all": "scripts/build.js",
     "build:es": "babel --out-dir es src --ignore '**/__tests__,**/__mocks__' --extensions '.ts,.tsx,.js,.jsx'",
     "build:types": "tsc",
     "build:canvas": "yarn run build",
     "build:watch": "yarn clean:es && yarn build:es --watch",
     "build:cafe": "wp --config webpack.testcafe.config.js",
-    "prepublishOnly": "yarn build:all && yarn test",
+    "prepublishOnly": "yarn build && yarn test",
     "fmt:check": "biome check",
     "fmt:fix": "biome format --write",
     "clean": "rm -rf lib && yarn clean:es && rm -rf coverage && yarn demo:clean",