@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-75d011284-20250904

package/dist/cjs/shared/models/field_core.js

@@ -1,26 +1,16 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.FieldCore = void 0;
-require("core-js/modules/es.symbol.js");
-require("core-js/modules/es.symbol.description.js");
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _field_core = require("../types/field_core");
 var _private_utils = require("../private_utils");
 var _abstract_model = _interopRequireDefault(require("./abstract_model"));
-function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // This doesn't follow our enum naming conventions because we want the keys
 // to mirror the method/getter names on the model class.
-var WatchableFieldKeys = Object.freeze({
+const WatchableFieldKeys = Object.freeze({
   name: 'name',
   type: 'type',
   options: 'options',
@@ -37,295 +27,262 @@ var WatchableFieldKeys = Object.freeze({
  * - `isComputed`
  * - `description`
  */
+
 /** @hidden */
-var FieldCore = exports.FieldCore = /*#__PURE__*/function (_AbstractModel) {
+class FieldCore extends _abstract_model.default {
+  /** @internal */
+  static _className = 'FieldCore';
+  /** @internal */
+  static _isWatchableKey(key) {
+    return (0, _private_utils.isEnumValue)(WatchableFieldKeys, key);
+  }
+  /** @internal */
+
+  /** @internal */
+
   /**
    * @internal
    */
-  function FieldCore(sdk, parentTable, fieldId) {
-    var _this;
-    (0, _classCallCheck2.default)(this, FieldCore);
-    _this = _callSuper(this, FieldCore, [sdk, fieldId]);
-    /** @internal */
-    (0, _defineProperty2.default)(_this, "_parentTable", void 0);
-    /** @internal */
-    (0, _defineProperty2.default)(_this, "_cachedFieldTypeConfigOrNull", void 0);
-    _this._parentTable = parentTable;
-    _this._cachedFieldTypeConfigOrNull = null;
-    return _this;
+  constructor(sdk, parentTable, fieldId) {
+    super(sdk, fieldId);
+    this._parentTable = parentTable;
+    this._cachedFieldTypeConfigOrNull = null;
   }
 
   /**
    * @internal
    */
-  (0, _inherits2.default)(FieldCore, _AbstractModel);
-  return (0, _createClass2.default)(FieldCore, [{
-    key: "_dataOrNullIfDeleted",
-    get: function get() {
-      var _tableData$fieldsById;
-      var tableData = this._baseData.tablesById[this.parentTable.id];
-      return (_tableData$fieldsById = tableData === null || tableData === void 0 ? void 0 : tableData.fieldsById[this._id]) !== null && _tableData$fieldsById !== void 0 ? _tableData$fieldsById : null;
-    }
-    /**
-     * The table that this field belongs to. Should never change because fields aren't moved between tables.
-     *
-     * @internal (since we may not be able to return parent model instances in the immutable models world)
-     * @example
-     * ```js
-     * const field = myTable.getFieldByName('Name');
-     * console.log(field.parentTable.id === myTable.id);
-     * // => true
-     * ```
-     */
-  }, {
-    key: "parentTable",
-    get: function get() {
-      return this._parentTable;
-    }
-    /**
-     * The name of the field. Can be watched.
-     *
-     * @example
-     * ```js
-     * console.log(myField.name);
-     * // => 'Name'
-     * ```
-     */
-  }, {
-    key: "name",
-    get: function get() {
-      return this._data.name;
-    }
-    /**
-     * The type of the field. Can be watched.
-     *
-     * @example
-     * ```js
-     * console.log(myField.type);
-     * // => 'singleLineText'
-     * ```
-     */
-  }, {
-    key: "type",
-    get: function get() {
-      var _this$_getCachedConfi = this._getCachedConfigFromFieldTypeProvider(),
-        type = _this$_getCachedConfi.type;
-      // We intend to switch from "lookup" to "multipleLookupValues", but need to support both
-      // until the transition is complete. See <https://airtable.quip.com/VxaMAmAfUscs> for more.
-      // @ts-ignore
-      if (type === 'lookup') {
-        return _field_core.FieldType.MULTIPLE_LOOKUP_VALUES;
-      } else {
-        return type;
-      }
+  get _dataOrNullIfDeleted() {
+    const tableData = this._baseData.tablesById[this.parentTable.id];
+    return tableData?.fieldsById[this._id] ?? null;
+  }
+  /**
+   * The table that this field belongs to. Should never change because fields aren't moved between tables.
+   *
+   * @internal (since we may not be able to return parent model instances in the immutable models world)
+   * @example
+   * ```js
+   * const field = myTable.getFieldByName('Name');
+   * console.log(field.parentTable.id === myTable.id);
+   * // => true
+   * ```
+   */
+  get parentTable() {
+    return this._parentTable;
+  }
+  /**
+   * The name of the field. Can be watched.
+   *
+   * @example
+   * ```js
+   * console.log(myField.name);
+   * // => 'Name'
+   * ```
+   */
+  get name() {
+    return this._data.name;
+  }
+  /**
+   * The type of the field. Can be watched.
+   *
+   * @example
+   * ```js
+   * console.log(myField.type);
+   * // => 'singleLineText'
+   * ```
+   */
+  get type() {
+    const {
+      type
+    } = this._getCachedConfigFromFieldTypeProvider();
+    // We intend to switch from "lookup" to "multipleLookupValues", but need to support both
+    // until the transition is complete. See <https://airtable.quip.com/VxaMAmAfUscs> for more.
+    // @ts-ignore
+    if (type === 'lookup') {
+      return _field_core.FieldType.MULTIPLE_LOOKUP_VALUES;
+    } else {
+      return type;
     }
-    /**
-     * The configuration options of the field. The structure of the field's
-     * options depend on the field's type. `null` if the field has no options.
-     * See {@link FieldType} for more information on the options for each field
-     * type. Can be watched.
-     *
-     * @see {@link FieldType}
-     * @example
-     * ```js
-     * import {FieldType} from '@airtable/blocks/[placeholder-path]/models';
-     *
-     * if (myField.type === FieldType.CURRENCY) {
-     *     console.log(myField.options.symbol);
-     *     // => '$'
-     * }
-     * ```
-     */
-  }, {
-    key: "options",
-    get: function get() {
-      var _this$_getCachedConfi2 = this._getCachedConfigFromFieldTypeProvider(),
-        options = _this$_getCachedConfi2.options;
+  }
+  /**
+   * The configuration options of the field. The structure of the field's
+   * options depend on the field's type. `null` if the field has no options.
+   * See {@link FieldType} for more information on the options for each field
+   * type. Can be watched.
+   *
+   * @see {@link FieldType}
+   * @example
+   * ```js
+   * import {FieldType} from '@airtable/blocks/[placeholder-path]/models';
+   *
+   * if (myField.type === FieldType.CURRENCY) {
+   *     console.log(myField.options.symbol);
+   *     // => '$'
+   * }
+   * ```
+   */
+  get options() {
+    const {
+      options
+    } = this._getCachedConfigFromFieldTypeProvider();
 
-      // TODO: In the next breaking release freeze (inside of the cache) and replace
-      // FieldOptions with readonly<FieldOptions>.
-      // Today this is required because we re-use the fieldTypeProvider.getConfig response.
-      return options ? (0, _private_utils.cloneDeep)(options) : null;
-    }
+    // TODO: In the next breaking release freeze (inside of the cache) and replace
+    // FieldOptions with readonly<FieldOptions>.
+    // Today this is required because we re-use the fieldTypeProvider.getConfig response.
+    return options ? (0, _private_utils.cloneDeep)(options) : null;
+  }
 
-    // We use a cached response from FieldTypeProvider because getting the config can
-    // be an expensive operation. In particular when fieldConfigs are extremely large
-    // (eg: Select fields with lots of select options)
-  }, {
-    key: "_getCachedConfigFromFieldTypeProvider",
-    value: function _getCachedConfigFromFieldTypeProvider() {
-      if (this._cachedFieldTypeConfigOrNull !== null) {
-        return this._cachedFieldTypeConfigOrNull;
-      }
-      var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
-      this._cachedFieldTypeConfigOrNull = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById());
+  // We use a cached response from FieldTypeProvider because getting the config can
+  // be an expensive operation. In particular when fieldConfigs are extremely large
+  // (eg: Select fields with lots of select options)
+  _getCachedConfigFromFieldTypeProvider() {
+    if (this._cachedFieldTypeConfigOrNull !== null) {
       return this._cachedFieldTypeConfigOrNull;
     }
-  }, {
-    key: "_clearCachedConfig",
-    value: function _clearCachedConfig() {
-      this._cachedFieldTypeConfigOrNull = null;
-    }
+    const airtableInterface = this._sdk.__airtableInterface;
+    const appInterface = this._sdk.__appInterface;
+    this._cachedFieldTypeConfigOrNull = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById());
+    return this._cachedFieldTypeConfigOrNull;
+  }
+  _clearCachedConfig() {
+    this._cachedFieldTypeConfigOrNull = null;
+  }
 
-    /**
-     * The type and options of the field to make type narrowing `FieldOptions` easier.
-     * See {@link FieldType} for more information on the options for each field type.
-     *
-     * @see {@link FieldConfig}
-     * @example
-     * const fieldConfig = field.config;
-     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
-     *     return fieldConfig.options.choices;
-     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
-     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
-     *         return fieldConfig.options.result.options.choices;
-     *     }
-     * }
-     * return DEFAULT_CHOICES;
-     */
-  }, {
-    key: "config",
-    get: function get() {
-      return {
-        type: this.type,
-        options: this.options
-      };
-    }
+  /**
+   * The type and options of the field to make type narrowing `FieldOptions` easier.
+   * See {@link FieldType} for more information on the options for each field type.
+   *
+   * @see {@link FieldConfig}
+   * @example
+   * const fieldConfig = field.config;
+   * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
+   *     return fieldConfig.options.choices;
+   * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
+   *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
+   *         return fieldConfig.options.result.options.choices;
+   *     }
+   * }
+   * return DEFAULT_CHOICES;
+   */
+  get config() {
+    return {
+      type: this.type,
+      options: this.options
+    };
+  }
+
+  /**
+   * `true` if this field is synced, `false` otherwise. A field is
+   * "synced" if it's source is from another airtable base or external data source
+   * like Google Calendar, Jira, etc..
+   *
+   * @hidden
+   */
+  get isFieldSynced() {
+    return this._data.isSynced ?? false;
+  }
+
+  /**
+   * `true` if this field is computed, `false` otherwise. A field is
+   * "computed" if it's value is not set by user input (e.g. autoNumber, formula,
+   * etc.). Can be watched
+   *
+   * @example
+   * ```js
+   * console.log(mySingleLineTextField.isComputed);
+   * // => false
+   * console.log(myAutoNumberField.isComputed);
+   * // => true
+   * ```
+   */
+  get isComputed() {
+    const airtableInterface = this._sdk.__airtableInterface;
+    return airtableInterface.fieldTypeProvider.isComputed(this._data);
+  }
+  /**
+   * `true` if this field is its parent table's primary field, `false` otherwise.
+   * Should never change because the primary field of a table cannot change.
+   */
+  get isPrimaryField() {
+    return this.id === this.parentTable.primaryField.id;
+  }
+
+  /**
+   * The description of the field, if it has one. Can be watched.
+   *
+   * @example
+   * ```js
+   * console.log(myField.description);
+   * // => 'This is my field'
+   * ```
+   */
+  get description() {
+    return this._data.description;
+  }
+  /**
+   * Attempt to parse a given string and return a valid cell value for the field's current config.
+   * Returns `null` if unable to parse the given string.
+   *
+   * @param string The string to parse.
+   * @example
+   * ```js
+   * const inputString = '42';
+   * const cellValue = myNumberField.convertStringToCellValue(inputString);
+   * console.log(cellValue === 42);
+   * // => true
+   * ```
+   */
+  convertStringToCellValue(string) {
+    const airtableInterface = this._sdk.__airtableInterface;
+    const appInterface = this._sdk.__appInterface;
+    const cellValue = airtableInterface.fieldTypeProvider.convertStringToCellValue(appInterface, string, this._data,
+    // The opt parseDateCellValueInColumnTimeZone is used here to ensure date string
+    // inputs are interpreted correctly according to the `timeZone` of the dateTime field.
+    {
+      parseDateCellValueInColumnTimeZone: this.type === _field_core.FieldType.DATE_TIME
+    });
 
-    /**
-     * `true` if this field is synced, `false` otherwise. A field is
-     * "synced" if it's source is from another airtable base or external data source
-     * like Google Calendar, Jira, etc..
-     *
-     * @hidden
-     */
-  }, {
-    key: "isFieldSynced",
-    get: function get() {
-      var _this$_data$isSynced;
-      return (_this$_data$isSynced = this._data.isSynced) !== null && _this$_data$isSynced !== void 0 ? _this$_data$isSynced : false;
+    // Temporarily bail out of validating computed values (since validation will crash)
+    // while we work out if we actually have to validate or not. Ideally we just delete all
+    // the validation
+    // TODO(emma): delete me or tidy me up
+    if (this.isComputed) {
+      return cellValue;
     }
 
-    /**
-     * `true` if this field is computed, `false` otherwise. A field is
-     * "computed" if it's value is not set by user input (e.g. autoNumber, formula,
-     * etc.). Can be watched
-     *
-     * @example
-     * ```js
-     * console.log(mySingleLineTextField.isComputed);
-     * // => false
-     * console.log(myAutoNumberField.isComputed);
-     * // => true
-     * ```
-     */
-  }, {
-    key: "isComputed",
-    get: function get() {
-      var airtableInterface = this._sdk.__airtableInterface;
-      return airtableInterface.fieldTypeProvider.isComputed(this._data);
+    // TODO(emma): do we need to validate here?
+    const validationResult = airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, cellValue, null, this._data);
+    if (validationResult.isValid) {
+      return cellValue;
+    } else {
+      return null;
     }
-    /**
-     * `true` if this field is its parent table's primary field, `false` otherwise.
-     * Should never change because the primary field of a table cannot change.
-     */
-  }, {
-    key: "isPrimaryField",
-    get: function get() {
-      return this.id === this.parentTable.primaryField.id;
+  }
+  /**
+   * @internal
+   */
+  __triggerOnChangeForDirtyPaths(dirtyPaths) {
+    // Always clear the cached config when anything on the field data model changes
+    this._clearCachedConfig();
+    if (dirtyPaths.name) {
+      this._onChange(WatchableFieldKeys.name);
     }
+    if (dirtyPaths.type) {
+      this._onChange(WatchableFieldKeys.type);
 
-    /**
-     * The description of the field, if it has one. Can be watched.
-     *
-     * @example
-     * ```js
-     * console.log(myField.description);
-     * // => 'This is my field'
-     * ```
-     */
-  }, {
-    key: "description",
-    get: function get() {
-      return this._data.description;
+      // TODO: it would be better if we only trigger this when
+      // we know isComputed changed.
+      this._onChange(WatchableFieldKeys.isComputed);
     }
-    /**
-     * Attempt to parse a given string and return a valid cell value for the field's current config.
-     * Returns `null` if unable to parse the given string.
-     *
-     * @param string The string to parse.
-     * @example
-     * ```js
-     * const inputString = '42';
-     * const cellValue = myNumberField.convertStringToCellValue(inputString);
-     * console.log(cellValue === 42);
-     * // => true
-     * ```
-     */
-  }, {
-    key: "convertStringToCellValue",
-    value: function convertStringToCellValue(string) {
-      var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
-      var cellValue = airtableInterface.fieldTypeProvider.convertStringToCellValue(appInterface, string, this._data,
-      // The opt parseDateCellValueInColumnTimeZone is used here to ensure date string
-      // inputs are interpreted correctly according to the `timeZone` of the dateTime field.
-      {
-        parseDateCellValueInColumnTimeZone: this.type === _field_core.FieldType.DATE_TIME
-      });
-
-      // Temporarily bail out of validating computed values (since validation will crash)
-      // while we work out if we actually have to validate or not. Ideally we just delete all
-      // the validation
-      // TODO(emma): delete me or tidy me up
-      if (this.isComputed) {
-        return cellValue;
-      }
-
-      // TODO(emma): do we need to validate here?
-      var validationResult = airtableInterface.fieldTypeProvider.validateCellValueForUpdate(appInterface, cellValue, null, this._data);
-      if (validationResult.isValid) {
-        return cellValue;
-      } else {
-        return null;
-      }
+    if (dirtyPaths.typeOptions) {
+      this._onChange(WatchableFieldKeys.options);
     }
-    /**
-     * @internal
-     */
-  }, {
-    key: "__triggerOnChangeForDirtyPaths",
-    value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
-      // Always clear the cached config when anything on the field data model changes
-      this._clearCachedConfig();
-      if (dirtyPaths.name) {
-        this._onChange(WatchableFieldKeys.name);
-      }
-      if (dirtyPaths.type) {
-        this._onChange(WatchableFieldKeys.type);
-
-        // TODO: it would be better if we only trigger this when
-        // we know isComputed changed.
-        this._onChange(WatchableFieldKeys.isComputed);
-      }
-      if (dirtyPaths.typeOptions) {
-        this._onChange(WatchableFieldKeys.options);
-      }
-      if (dirtyPaths.description) {
-        this._onChange(WatchableFieldKeys.description);
-      }
-      if (dirtyPaths.isSynced) {
-        this._onChange(WatchableFieldKeys.isFieldSynced);
-      }
+    if (dirtyPaths.description) {
+      this._onChange(WatchableFieldKeys.description);
     }
-  }], [{
-    key: "_isWatchableKey",
-    value: /** @internal */
-    function _isWatchableKey(key) {
-      return (0, _private_utils.isEnumValue)(WatchableFieldKeys, key);
+    if (dirtyPaths.isSynced) {
+      this._onChange(WatchableFieldKeys.isFieldSynced);
     }
-  }]);
-}(_abstract_model.default);
-/** @internal */
-(0, _defineProperty2.default)(FieldCore, "_className", 'FieldCore');
+  }
+}
+exports.FieldCore = FieldCore;