@oracle/oraclejet-core-pack 14.0.0

package/oj-c/text-area/__webdriver__/index.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.findTextArea = exports.TextAreaWebElement = void 0;
+var oraclejet_webdriver_1 = require("@oracle/oraclejet-webdriver");
+var TextAreaWebElement_1 = require("./TextAreaWebElement");
+exports.TextAreaWebElement = TextAreaWebElement_1.TextAreaWebElement;
+/**
+ * Retrieve an instance of [[TextAreaWebElement]].
+ * @example
+ * ```javascript
+ * import { findTextArea } from '@oracle/oraclejet-core-pack/webdriver';
+ * const el = await findTextArea(driver, By.id('my-oj-c-text-area'));
+ * ```
+ * @param driver A WebDriver/WebElement instance from where the element will be
+ * searched. If WebDriver is passed, the element will be searched globally in the
+ * document. If WebElement is passed, the search will be relative to this element.
+ * @param by The locator with which to find the element
+ */
+function findTextArea(driver, by) {
+    return __awaiter(this, void 0, void 0, function () {
+        var webEl, tagName;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, driver.findElement(by)];
+                case 1:
+                    webEl = _a.sent();
+                    if (!!(webEl instanceof TextAreaWebElement_1.TextAreaWebElement)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, webEl.getTagName()];
+                case 2:
+                    tagName = _a.sent();
+                    throw Error("findTextArea(".concat(by, ") created ").concat(webEl.constructor.name, " for <").concat(tagName, ">, but expected ").concat(TextAreaWebElement_1.TextAreaWebElement.name));
+                case 3: return [2 /*return*/, webEl];
+            }
+        });
+    });
+}
+exports.findTextArea = findTextArea;
+(0, oraclejet_webdriver_1.register)('oj-c-text-area', TextAreaWebElement_1.TextAreaWebElement);

package/oj-c/text-area/component.json

@@ -0,0 +1,497 @@
+{
+  "name": "text-area",
+  "version": "1.0.0",
+  "jetVersion": "^14.0.0",
+  "type": "composite",
+  "pack": "oj-c",
+  "implements": [
+    "CTextAreaElement"
+  ],
+  "displayName": "TextArea",
+  "description": "A text area displays a field that allows a user to enter a multi-line text value",
+  "help": "oj-c.TextArea.html",
+  "main": "oj-c/text-area",
+  "extension": {
+    "vbdt": {
+      "module": "oj-c/text-area",
+      "defaultColumns": 6,
+      "minColumns": 2
+    },
+    "oracle": {
+      "icon": "oj-ux-ico-text-input-area"
+    }
+  },
+  "since": "13.0.0",
+  "properties": {
+    "autocomplete": {
+      "type": "string",
+      "description": "Dictates component's autocomplete state",
+      "displayName": "Autocomplete",
+      "help": "#autocomplete",
+      "value": "on"
+    },
+    "containerReadonly": {
+      "type": "boolean",
+      "description": "Specifies whether an ancestor container, like oj-form-layout, is readonly.",
+      "displayName": "Container Readonly",
+      "help": "#containerReadonly",
+      "binding": {
+        "consume": {
+          "name": "containerReadonly"
+        }
+      }
+    },
+    "converter": {
+      "type": "object|null",
+      "description": "Specifies the converter instance.",
+      "displayName": "Converter",
+      "help": "#converter",
+      "value": null
+    },
+    "disabled": {
+      "type": "boolean",
+      "description": "Specifies whether the component is disabled.",
+      "displayName": "Disabled",
+      "help": "#disabled",
+      "value": false
+    },
+    "displayOptions": {
+      "type": "object",
+      "description": "Display options for auxiliary content that determines whether or not it should be displayed.",
+      "displayName": "Display Options",
+      "help": "#displayOptions",
+      "properties": {
+        "converterHint": {
+          "type": "string",
+          "enumValues": [
+            "display",
+            "none"
+          ],
+          "value": "display"
+        },
+        "messages": {
+          "type": "string",
+          "enumValues": [
+            "display",
+            "none"
+          ],
+          "value": "display"
+        },
+        "validatorHint": {
+          "type": "string",
+          "enumValues": [
+            "display",
+            "none"
+          ],
+          "value": "display"
+        }
+      }
+    },
+    "help": {
+      "type": "object",
+      "description": "Form component help information.",
+      "displayName": "Help",
+      "help": "#help",
+      "properties": {
+        "instruction": {
+          "type": "string",
+          "value": ""
+        }
+      }
+    },
+    "helpHints": {
+      "type": "object",
+      "description": "The helpHints object contains a definition property and a source property.",
+      "displayName": "Help Hints",
+      "help": "#helpHints",
+      "properties": {
+        "definition": {
+          "type": "string",
+          "value": ""
+        },
+        "source": {
+          "type": "string",
+          "value": ""
+        },
+        "sourceText": {
+          "type": "string"
+        }
+      }
+    },
+    "labelEdge": {
+      "type": "string",
+      "description": "Specifies how the label is positioned for the component",
+      "displayName": "Label Edge",
+      "help": "#labelEdge",
+      "propertyEditorValues": {
+        "inside": {
+          "description": "The label floats over the input element, but moves up on focus or when the component has a value (default, if unspecified).",
+          "displayName": "Inside"
+        },
+        "none": {
+          "description": "The component will not create a label, but instead set the aria-label property on the input element.",
+          "displayName": "None"
+        },
+        "start": {
+          "description": "The label will be placed before the start of the component.",
+          "displayName": "Start"
+        },
+        "top": {
+          "description": "The label will be placed on top of the component.",
+          "displayName": "Top"
+        }
+      },
+      "enumValues": [
+        "start",
+        "none",
+        "top",
+        "inside"
+      ],
+      "binding": {
+        "consume": {
+          "name": "containerLabelEdge"
+        }
+      }
+    },
+    "labelHint": {
+      "type": "string",
+      "description": "Represents a hint for rendering a label on the component.",
+      "displayName": "Label Hint",
+      "help": "#labelHint",
+      "required": true,
+      "translatable": true
+    },
+    "labelStartWidth": {
+      "type": "string",
+      "description": "The width of the label when labelEdge is 'start'.",
+      "displayName": "Label Start Width",
+      "help": "#labelStartWidth",
+      "binding": {
+        "consume": {
+          "name": "labelWidth"
+        }
+      }
+    },
+    "labelWrapping": {
+      "type": "string",
+      "description": "Should the labels wrap or truncate when there is not enough available space.",
+      "displayName": "Label Wrapping",
+      "help": "#labelWrapping",
+      "propertyEditorValues": {
+        "truncate": {
+          "description": "Label will truncate if needed.",
+          "displayName": "Truncate"
+        },
+        "wrap": {
+          "description": "Label will wrap if needed.",
+          "displayName": "Wrap"
+        }
+      },
+      "enumValues": [
+        "wrap",
+        "truncate"
+      ],
+      "binding": {
+        "consume": {
+          "name": "labelWrapping"
+        }
+      }
+    },
+    "length": {
+      "type": "object",
+      "description": "Defines the length limit for the field",
+      "displayName": "Length",
+      "help": "#length",
+      "properties": {
+        "countBy": {
+          "type": "string",
+          "enumValues": [
+            "codePoint",
+            "codeUnit"
+          ],
+          "value": "codePoint"
+        },
+        "counter": {
+          "type": "string",
+          "enumValues": [
+            "none",
+            "remaining"
+          ]
+        },
+        "max": {
+          "type": "number|null",
+          "value": null
+        }
+      }
+    },
+    "maxRows": {
+      "type": "number",
+      "description": "The maximum number of visible text lines of the textarea.",
+      "displayName": "Max Rows",
+      "help": "#maxRows"
+    },
+    "messagesCustom": {
+      "type": "Array<object>",
+      "description": "List of custom component messages",
+      "displayName": "Messages Custom",
+      "help": "#messagesCustom",
+      "extension": {
+        "vbdt": {
+          "itemProperties": {
+            "summary": {
+              "type": "string"
+            },
+            "detail": {
+              "type": "string"
+            },
+            "severity": {
+              "type": "string",
+              "enumValues": [
+                "error",
+                "confirmation",
+                "info",
+                "warning"
+              ]
+            }
+          }
+        }
+      },
+      "writeback": true,
+      "value": []
+    },
+    "placeholder": {
+      "type": "string",
+      "description": "The placeholder text to set on the element.",
+      "displayName": "Placeholder",
+      "help": "#placeholder",
+      "translatable": true
+    },
+    "readonly": {
+      "type": "boolean",
+      "description": "Whether the component is readonly",
+      "displayName": "Readonly",
+      "help": "#readonly",
+      "binding": {
+        "consume": {
+          "name": "containerReadonly"
+        }
+      },
+      "value": false
+    },
+    "required": {
+      "type": "boolean",
+      "description": "Specifies whether or not the component is required.",
+      "displayName": "Required",
+      "help": "#required",
+      "value": false
+    },
+    "requiredMessageDetail": {
+      "type": "string",
+      "description": "Overrides the default Required error message.",
+      "displayName": "Required Message Detail",
+      "help": "#requiredMessageDetail",
+      "translatable": true
+    },
+    "resizeBehavior": {
+      "type": "string",
+      "description": "Defines the resizeBehavior of the textarea.",
+      "displayName": "Resize Behavior",
+      "help": "#resizeBehavior",
+      "propertyEditorValues": {
+        "horizontal": {
+          "description": "The textarea will be resizable in the horizontal direction only.",
+          "displayName": "Horizontal"
+        },
+        "vertical": {
+          "description": "The textarea will be resizable in the vertical direction only.",
+          "displayName": "Vertical"
+        },
+        "both": {
+          "description": "The textarea will be interactively resizable both horizontally and vertically.",
+          "displayName": "Both"
+        },
+        "none": {
+          "description": "The textarea will not be resizable by the user.",
+          "displayName": "None"
+        }
+      },
+      "enumValues": [
+        "none",
+        "vertical",
+        "horizontal",
+        "both"
+      ],
+      "value": "none"
+    },
+    "rows": {
+      "type": "number",
+      "description": "The number of visible text lines in the textarea.",
+      "displayName": "Rows",
+      "help": "#rows"
+    },
+    "textAlign": {
+      "type": "string",
+      "description": "Specifies how the text is aligned within the text field",
+      "displayName": "Text Align",
+      "help": "#textAlign",
+      "propertyEditorValues": {
+        "start": {
+          "description": "Aligns text left when reading direction is ltr and right when reading direction is rtl (default, if unspecified).",
+          "displayName": "Start"
+        },
+        "end": {
+          "description": "Aligns text right when reading direction is ltr and left when reading direction is rtl.",
+          "displayName": "End"
+        },
+        "right": {
+          "description": "Aligns text right regardless of reading direction, often used for numbers.",
+          "displayName": "Right"
+        }
+      },
+      "enumValues": [
+        "start",
+        "right",
+        "end"
+      ]
+    },
+    "userAssistanceDensity": {
+      "type": "string",
+      "description": "Specifies the density of the form component's user assistance presentation.",
+      "displayName": "User Assistance Density",
+      "help": "#userAssistanceDensity",
+      "propertyEditorValues": {
+        "reflow": {
+          "description": "Messages, help, hints, and required are all shown inline under the field with no reserved space.",
+          "displayName": "Reflow"
+        },
+        "efficient": {
+          "description": "Messages, help, hints, and required are all shown inline under the field with reserved space.",
+          "displayName": "Efficient"
+        }
+      },
+      "enumValues": [
+        "reflow",
+        "efficient"
+      ],
+      "binding": {
+        "consume": {
+          "name": "containerUserAssistanceDensity"
+        }
+      },
+      "value": "reflow"
+    },
+    "validators": {
+      "type": "Array<object>|null",
+      "description": "Specifies the validators for the component.",
+      "displayName": "Validators",
+      "help": "#validators",
+      "value": []
+    },
+    "value": {
+      "type": "any",
+      "description": "The value of the component.",
+      "displayName": "Value",
+      "help": "#value",
+      "writeback": true,
+      "value": null
+    },
+    "rawValue": {
+      "type": "string",
+      "description": "Specifies how the raw value of the component",
+      "displayName": "Raw Value",
+      "help": "#rawValue",
+      "readOnly": true,
+      "writeback": true
+    },
+    "valid": {
+      "type": "string",
+      "description": "Specifies how the valid state of the component",
+      "displayName": "Valid",
+      "help": "#valid",
+      "propertyEditorValues": {
+        "valid": {
+          "description": "The component is valid",
+          "displayName": "Valid"
+        },
+        "pending": {
+          "description": "The component is waiting for the validation state to be determined. The 'pending' state is set at the start of the convert/validate process.",
+          "displayName": "Pending"
+        },
+        "invalidHidden": {
+          "description": "The component has invalid messages hidden and no invalid messages showing. An invalid message is one with severity 'error'.",
+          "displayName": "Invalid Hidden"
+        },
+        "invalidShown": {
+          "description": "The component has invalid messages showing. An invalid message is one with severity 'error'.",
+          "displayName": "Invalid Shown"
+        }
+      },
+      "enumValues": [
+        "valid",
+        "pending",
+        "invalidHidden",
+        "invalidShown"
+      ],
+      "readOnly": true,
+      "writeback": true
+    }
+  },
+  "methods": {
+    "reset": {
+      "return": "any"
+    },
+    "showMessages": {
+      "return": "any"
+    },
+    "validate": {
+      "return": "Promise"
+    },
+    "blur": {
+      "return": "any"
+    },
+    "focus": {
+      "return": "any"
+    },
+    "setProperty": {
+      "description": "Sets a property or a single subproperty for complex properties and notifies the component of the change, triggering a corresponding event.",
+      "help": "#setProperty",
+      "params": [
+        {
+          "name": "property",
+          "description": "The property name to set. Supports dot notation for subproperty access.",
+          "type": "string"
+        },
+        {
+          "name": "value",
+          "description": "The new value to set the property to.",
+          "type": "any"
+        }
+      ],
+      "return": "void"
+    },
+    "getProperty": {
+      "description": "Retrieves the value of a property or a subproperty.",
+      "help": "#getProperty",
+      "params": [
+        {
+          "name": "property",
+          "description": "The property name to get. Supports dot notation for subproperty access.",
+          "type": "string"
+        }
+      ],
+      "return": "any"
+    },
+    "setProperties": {
+      "description": "Performs a batch set of properties.",
+      "help": "#setProperties",
+      "params": [
+        {
+          "name": "properties",
+          "description": "An object containing the property and value pairs to set.",
+          "type": "object"
+        }
+      ],
+      "return": "void"
+    }
+  }
+}

package/oj-c/text-area/index.js

@@ -0,0 +1,6 @@
+define(["require", "exports", "./text-area"], function (require, exports, text_area_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TextArea = void 0;
+    Object.defineProperty(exports, "TextArea", { enumerable: true, get: function () { return text_area_1.TextArea; } });
+});

package/oj-c/text-area/text-area-styles.css

@@ -0,0 +1,13 @@
+oj-c-text-area:not(.oj-complete) {
+  visibility: hidden;
+}
+
+oj-c-text-area {
+  display: inline-block;
+  max-width: 100%;
+  width: 100%;
+}
+
+oj-c-text-area[hidden] {
+  display: none;
+}